ibmveth.c 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636
  1. /**************************************************************************/
  2. /* */
  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) */
  7. /* */
  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. */
  12. /* */
  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. */
  17. /* */
  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 */
  21. /* USA */
  22. /* */
  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. */
  27. /* */
  28. /**************************************************************************/
  29. /*
  30. TODO:
  31. - add support for sysfs
  32. - possibly remove procfs support
  33. */
  34. #include <linux/module.h>
  35. #include <linux/moduleparam.h>
  36. #include <linux/types.h>
  37. #include <linux/errno.h>
  38. #include <linux/ioport.h>
  39. #include <linux/dma-mapping.h>
  40. #include <linux/kernel.h>
  41. #include <linux/netdevice.h>
  42. #include <linux/etherdevice.h>
  43. #include <linux/skbuff.h>
  44. #include <linux/init.h>
  45. #include <linux/delay.h>
  46. #include <linux/mm.h>
  47. #include <linux/pm.h>
  48. #include <linux/ethtool.h>
  49. #include <linux/proc_fs.h>
  50. #include <linux/in.h>
  51. #include <linux/ip.h>
  52. #include <linux/slab.h>
  53. #include <net/net_namespace.h>
  54. #include <asm/hvcall.h>
  55. #include <asm/atomic.h>
  56. #include <asm/vio.h>
  57. #include <asm/iommu.h>
  58. #include <asm/uaccess.h>
  59. #include <asm/firmware.h>
  60. #include <linux/seq_file.h>
  61. #include "ibmveth.h"
  62. #undef DEBUG
  63. #define ibmveth_printk(fmt, args...) \
  64. printk(KERN_DEBUG "%s: " fmt, __FILE__, ## args)
  65. #define ibmveth_error_printk(fmt, args...) \
  66. printk(KERN_ERR "(%s:%3.3d ua:%x) ERROR: " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
  67. #ifdef DEBUG
  68. #define ibmveth_debug_printk_no_adapter(fmt, args...) \
  69. printk(KERN_DEBUG "(%s:%3.3d): " fmt, __FILE__, __LINE__ , ## args)
  70. #define ibmveth_debug_printk(fmt, args...) \
  71. printk(KERN_DEBUG "(%s:%3.3d ua:%x): " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
  72. #define ibmveth_assert(expr) \
  73. if(!(expr)) { \
  74. printk(KERN_DEBUG "assertion failed (%s:%3.3d ua:%x): %s\n", __FILE__, __LINE__, adapter->vdev->unit_address, #expr); \
  75. BUG(); \
  76. }
  77. #else
  78. #define ibmveth_debug_printk_no_adapter(fmt, args...)
  79. #define ibmveth_debug_printk(fmt, args...)
  80. #define ibmveth_assert(expr)
  81. #endif
  82. static int ibmveth_open(struct net_device *dev);
  83. static int ibmveth_close(struct net_device *dev);
  84. static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
  85. static int ibmveth_poll(struct napi_struct *napi, int budget);
  86. static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *dev);
  87. static void ibmveth_set_multicast_list(struct net_device *dev);
  88. static int ibmveth_change_mtu(struct net_device *dev, int new_mtu);
  89. static void ibmveth_proc_register_driver(void);
  90. static void ibmveth_proc_unregister_driver(void);
  91. static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter);
  92. static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter);
  93. static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance);
  94. static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
  95. static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev);
  96. static struct kobj_type ktype_veth_pool;
  97. #ifdef CONFIG_PROC_FS
  98. #define IBMVETH_PROC_DIR "ibmveth"
  99. static struct proc_dir_entry *ibmveth_proc_dir;
  100. #endif
  101. static const char ibmveth_driver_name[] = "ibmveth";
  102. static const char ibmveth_driver_string[] = "IBM i/pSeries Virtual Ethernet Driver";
  103. #define ibmveth_driver_version "1.03"
  104. MODULE_AUTHOR("Santiago Leon <santil@us.ibm.com>");
  105. MODULE_DESCRIPTION("IBM i/pSeries Virtual Ethernet Driver");
  106. MODULE_LICENSE("GPL");
  107. MODULE_VERSION(ibmveth_driver_version);
  108. struct ibmveth_stat {
  109. char name[ETH_GSTRING_LEN];
  110. int offset;
  111. };
  112. #define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
  113. #define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
  114. struct ibmveth_stat ibmveth_stats[] = {
  115. { "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles) },
  116. { "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem) },
  117. { "replenish_add_buff_failure", IBMVETH_STAT_OFF(replenish_add_buff_failure) },
  118. { "replenish_add_buff_success", IBMVETH_STAT_OFF(replenish_add_buff_success) },
  119. { "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer) },
  120. { "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer) },
  121. { "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) },
  122. { "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) },
  123. };
  124. /* simple methods of getting data from the current rxq entry */
  125. static inline u32 ibmveth_rxq_flags(struct ibmveth_adapter *adapter)
  126. {
  127. return adapter->rx_queue.queue_addr[adapter->rx_queue.index].flags_off;
  128. }
  129. static inline int ibmveth_rxq_toggle(struct ibmveth_adapter *adapter)
  130. {
  131. return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >> IBMVETH_RXQ_TOGGLE_SHIFT;
  132. }
  133. static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)
  134. {
  135. return (ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle);
  136. }
  137. static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter *adapter)
  138. {
  139. return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID);
  140. }
  141. static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter *adapter)
  142. {
  143. return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK);
  144. }
  145. static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
  146. {
  147. return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);
  148. }
  149. static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)
  150. {
  151. return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_CSUM_GOOD);
  152. }
  153. /* setup the initial settings for a buffer pool */
  154. static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool, u32 pool_index, u32 pool_size, u32 buff_size, u32 pool_active)
  155. {
  156. pool->size = pool_size;
  157. pool->index = pool_index;
  158. pool->buff_size = buff_size;
  159. pool->threshold = pool_size / 2;
  160. pool->active = pool_active;
  161. }
  162. /* allocate and setup an buffer pool - called during open */
  163. static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
  164. {
  165. int i;
  166. pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL);
  167. if(!pool->free_map) {
  168. return -1;
  169. }
  170. pool->dma_addr = kmalloc(sizeof(dma_addr_t) * pool->size, GFP_KERNEL);
  171. if(!pool->dma_addr) {
  172. kfree(pool->free_map);
  173. pool->free_map = NULL;
  174. return -1;
  175. }
  176. pool->skbuff = kcalloc(pool->size, sizeof(void *), GFP_KERNEL);
  177. if(!pool->skbuff) {
  178. kfree(pool->dma_addr);
  179. pool->dma_addr = NULL;
  180. kfree(pool->free_map);
  181. pool->free_map = NULL;
  182. return -1;
  183. }
  184. memset(pool->dma_addr, 0, sizeof(dma_addr_t) * pool->size);
  185. for(i = 0; i < pool->size; ++i) {
  186. pool->free_map[i] = i;
  187. }
  188. atomic_set(&pool->available, 0);
  189. pool->producer_index = 0;
  190. pool->consumer_index = 0;
  191. return 0;
  192. }
  193. /* replenish the buffers for a pool. note that we don't need to
  194. * skb_reserve these since they are used for incoming...
  195. */
  196. static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struct ibmveth_buff_pool *pool)
  197. {
  198. u32 i;
  199. u32 count = pool->size - atomic_read(&pool->available);
  200. u32 buffers_added = 0;
  201. struct sk_buff *skb;
  202. unsigned int free_index, index;
  203. u64 correlator;
  204. unsigned long lpar_rc;
  205. dma_addr_t dma_addr;
  206. mb();
  207. for(i = 0; i < count; ++i) {
  208. union ibmveth_buf_desc desc;
  209. skb = alloc_skb(pool->buff_size, GFP_ATOMIC);
  210. if(!skb) {
  211. ibmveth_debug_printk("replenish: unable to allocate skb\n");
  212. adapter->replenish_no_mem++;
  213. break;
  214. }
  215. free_index = pool->consumer_index;
  216. pool->consumer_index = (pool->consumer_index + 1) % pool->size;
  217. index = pool->free_map[free_index];
  218. ibmveth_assert(index != IBM_VETH_INVALID_MAP);
  219. ibmveth_assert(pool->skbuff[index] == NULL);
  220. dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
  221. pool->buff_size, DMA_FROM_DEVICE);
  222. if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
  223. goto failure;
  224. pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
  225. pool->dma_addr[index] = dma_addr;
  226. pool->skbuff[index] = skb;
  227. correlator = ((u64)pool->index << 32) | index;
  228. *(u64*)skb->data = correlator;
  229. desc.fields.flags_len = IBMVETH_BUF_VALID | pool->buff_size;
  230. desc.fields.address = dma_addr;
  231. lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
  232. if (lpar_rc != H_SUCCESS)
  233. goto failure;
  234. else {
  235. buffers_added++;
  236. adapter->replenish_add_buff_success++;
  237. }
  238. }
  239. mb();
  240. atomic_add(buffers_added, &(pool->available));
  241. return;
  242. failure:
  243. pool->free_map[free_index] = index;
  244. pool->skbuff[index] = NULL;
  245. if (pool->consumer_index == 0)
  246. pool->consumer_index = pool->size - 1;
  247. else
  248. pool->consumer_index--;
  249. if (!dma_mapping_error(&adapter->vdev->dev, dma_addr))
  250. dma_unmap_single(&adapter->vdev->dev,
  251. pool->dma_addr[index], pool->buff_size,
  252. DMA_FROM_DEVICE);
  253. dev_kfree_skb_any(skb);
  254. adapter->replenish_add_buff_failure++;
  255. mb();
  256. atomic_add(buffers_added, &(pool->available));
  257. }
  258. /* replenish routine */
  259. static void ibmveth_replenish_task(struct ibmveth_adapter *adapter)
  260. {
  261. int i;
  262. adapter->replenish_task_cycles++;
  263. for (i = (IbmVethNumBufferPools - 1); i >= 0; i--)
  264. if(adapter->rx_buff_pool[i].active)
  265. ibmveth_replenish_buffer_pool(adapter,
  266. &adapter->rx_buff_pool[i]);
  267. adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
  268. }
  269. /* empty and free ana buffer pool - also used to do cleanup in error paths */
  270. static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibmveth_buff_pool *pool)
  271. {
  272. int i;
  273. kfree(pool->free_map);
  274. pool->free_map = NULL;
  275. if(pool->skbuff && pool->dma_addr) {
  276. for(i = 0; i < pool->size; ++i) {
  277. struct sk_buff *skb = pool->skbuff[i];
  278. if(skb) {
  279. dma_unmap_single(&adapter->vdev->dev,
  280. pool->dma_addr[i],
  281. pool->buff_size,
  282. DMA_FROM_DEVICE);
  283. dev_kfree_skb_any(skb);
  284. pool->skbuff[i] = NULL;
  285. }
  286. }
  287. }
  288. if(pool->dma_addr) {
  289. kfree(pool->dma_addr);
  290. pool->dma_addr = NULL;
  291. }
  292. if(pool->skbuff) {
  293. kfree(pool->skbuff);
  294. pool->skbuff = NULL;
  295. }
  296. }
  297. /* remove a buffer from a pool */
  298. static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter, u64 correlator)
  299. {
  300. unsigned int pool = correlator >> 32;
  301. unsigned int index = correlator & 0xffffffffUL;
  302. unsigned int free_index;
  303. struct sk_buff *skb;
  304. ibmveth_assert(pool < IbmVethNumBufferPools);
  305. ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
  306. skb = adapter->rx_buff_pool[pool].skbuff[index];
  307. ibmveth_assert(skb != NULL);
  308. adapter->rx_buff_pool[pool].skbuff[index] = NULL;
  309. dma_unmap_single(&adapter->vdev->dev,
  310. adapter->rx_buff_pool[pool].dma_addr[index],
  311. adapter->rx_buff_pool[pool].buff_size,
  312. DMA_FROM_DEVICE);
  313. free_index = adapter->rx_buff_pool[pool].producer_index;
  314. adapter->rx_buff_pool[pool].producer_index
  315. = (adapter->rx_buff_pool[pool].producer_index + 1)
  316. % adapter->rx_buff_pool[pool].size;
  317. adapter->rx_buff_pool[pool].free_map[free_index] = index;
  318. mb();
  319. atomic_dec(&(adapter->rx_buff_pool[pool].available));
  320. }
  321. /* get the current buffer on the rx queue */
  322. static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *adapter)
  323. {
  324. u64 correlator = adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator;
  325. unsigned int pool = correlator >> 32;
  326. unsigned int index = correlator & 0xffffffffUL;
  327. ibmveth_assert(pool < IbmVethNumBufferPools);
  328. ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
  329. return adapter->rx_buff_pool[pool].skbuff[index];
  330. }
  331. /* recycle the current buffer on the rx queue */
  332. static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
  333. {
  334. u32 q_index = adapter->rx_queue.index;
  335. u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator;
  336. unsigned int pool = correlator >> 32;
  337. unsigned int index = correlator & 0xffffffffUL;
  338. union ibmveth_buf_desc desc;
  339. unsigned long lpar_rc;
  340. ibmveth_assert(pool < IbmVethNumBufferPools);
  341. ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
  342. if(!adapter->rx_buff_pool[pool].active) {
  343. ibmveth_rxq_harvest_buffer(adapter);
  344. ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
  345. return;
  346. }
  347. desc.fields.flags_len = IBMVETH_BUF_VALID |
  348. adapter->rx_buff_pool[pool].buff_size;
  349. desc.fields.address = adapter->rx_buff_pool[pool].dma_addr[index];
  350. lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
  351. if(lpar_rc != H_SUCCESS) {
  352. ibmveth_debug_printk("h_add_logical_lan_buffer failed during recycle rc=%ld", lpar_rc);
  353. ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
  354. }
  355. if(++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
  356. adapter->rx_queue.index = 0;
  357. adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
  358. }
  359. }
  360. static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
  361. {
  362. ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
  363. if(++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
  364. adapter->rx_queue.index = 0;
  365. adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
  366. }
  367. }
  368. static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
  369. {
  370. int i;
  371. struct device *dev = &adapter->vdev->dev;
  372. if(adapter->buffer_list_addr != NULL) {
  373. if (!dma_mapping_error(dev, adapter->buffer_list_dma)) {
  374. dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
  375. DMA_BIDIRECTIONAL);
  376. adapter->buffer_list_dma = DMA_ERROR_CODE;
  377. }
  378. free_page((unsigned long)adapter->buffer_list_addr);
  379. adapter->buffer_list_addr = NULL;
  380. }
  381. if(adapter->filter_list_addr != NULL) {
  382. if (!dma_mapping_error(dev, adapter->filter_list_dma)) {
  383. dma_unmap_single(dev, adapter->filter_list_dma, 4096,
  384. DMA_BIDIRECTIONAL);
  385. adapter->filter_list_dma = DMA_ERROR_CODE;
  386. }
  387. free_page((unsigned long)adapter->filter_list_addr);
  388. adapter->filter_list_addr = NULL;
  389. }
  390. if(adapter->rx_queue.queue_addr != NULL) {
  391. if (!dma_mapping_error(dev, adapter->rx_queue.queue_dma)) {
  392. dma_unmap_single(dev,
  393. adapter->rx_queue.queue_dma,
  394. adapter->rx_queue.queue_len,
  395. DMA_BIDIRECTIONAL);
  396. adapter->rx_queue.queue_dma = DMA_ERROR_CODE;
  397. }
  398. kfree(adapter->rx_queue.queue_addr);
  399. adapter->rx_queue.queue_addr = NULL;
  400. }
  401. for(i = 0; i<IbmVethNumBufferPools; i++)
  402. if (adapter->rx_buff_pool[i].active)
  403. ibmveth_free_buffer_pool(adapter,
  404. &adapter->rx_buff_pool[i]);
  405. if (adapter->bounce_buffer != NULL) {
  406. if (!dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
  407. dma_unmap_single(&adapter->vdev->dev,
  408. adapter->bounce_buffer_dma,
  409. adapter->netdev->mtu + IBMVETH_BUFF_OH,
  410. DMA_BIDIRECTIONAL);
  411. adapter->bounce_buffer_dma = DMA_ERROR_CODE;
  412. }
  413. kfree(adapter->bounce_buffer);
  414. adapter->bounce_buffer = NULL;
  415. }
  416. }
  417. static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter,
  418. union ibmveth_buf_desc rxq_desc, u64 mac_address)
  419. {
  420. int rc, try_again = 1;
  421. /* After a kexec the adapter will still be open, so our attempt to
  422. * open it will fail. So if we get a failure we free the adapter and
  423. * try again, but only once. */
  424. retry:
  425. rc = h_register_logical_lan(adapter->vdev->unit_address,
  426. adapter->buffer_list_dma, rxq_desc.desc,
  427. adapter->filter_list_dma, mac_address);
  428. if (rc != H_SUCCESS && try_again) {
  429. do {
  430. rc = h_free_logical_lan(adapter->vdev->unit_address);
  431. } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
  432. try_again = 0;
  433. goto retry;
  434. }
  435. return rc;
  436. }
  437. static int ibmveth_open(struct net_device *netdev)
  438. {
  439. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  440. u64 mac_address = 0;
  441. int rxq_entries = 1;
  442. unsigned long lpar_rc;
  443. int rc;
  444. union ibmveth_buf_desc rxq_desc;
  445. int i;
  446. struct device *dev;
  447. ibmveth_debug_printk("open starting\n");
  448. napi_enable(&adapter->napi);
  449. for(i = 0; i<IbmVethNumBufferPools; i++)
  450. rxq_entries += adapter->rx_buff_pool[i].size;
  451. adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
  452. adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
  453. if(!adapter->buffer_list_addr || !adapter->filter_list_addr) {
  454. ibmveth_error_printk("unable to allocate filter or buffer list pages\n");
  455. ibmveth_cleanup(adapter);
  456. napi_disable(&adapter->napi);
  457. return -ENOMEM;
  458. }
  459. adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) * rxq_entries;
  460. adapter->rx_queue.queue_addr = kmalloc(adapter->rx_queue.queue_len, GFP_KERNEL);
  461. if(!adapter->rx_queue.queue_addr) {
  462. ibmveth_error_printk("unable to allocate rx queue pages\n");
  463. ibmveth_cleanup(adapter);
  464. napi_disable(&adapter->napi);
  465. return -ENOMEM;
  466. }
  467. dev = &adapter->vdev->dev;
  468. adapter->buffer_list_dma = dma_map_single(dev,
  469. adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL);
  470. adapter->filter_list_dma = dma_map_single(dev,
  471. adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL);
  472. adapter->rx_queue.queue_dma = dma_map_single(dev,
  473. adapter->rx_queue.queue_addr,
  474. adapter->rx_queue.queue_len, DMA_BIDIRECTIONAL);
  475. if ((dma_mapping_error(dev, adapter->buffer_list_dma)) ||
  476. (dma_mapping_error(dev, adapter->filter_list_dma)) ||
  477. (dma_mapping_error(dev, adapter->rx_queue.queue_dma))) {
  478. ibmveth_error_printk("unable to map filter or buffer list pages\n");
  479. ibmveth_cleanup(adapter);
  480. napi_disable(&adapter->napi);
  481. return -ENOMEM;
  482. }
  483. adapter->rx_queue.index = 0;
  484. adapter->rx_queue.num_slots = rxq_entries;
  485. adapter->rx_queue.toggle = 1;
  486. memcpy(&mac_address, netdev->dev_addr, netdev->addr_len);
  487. mac_address = mac_address >> 16;
  488. rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | adapter->rx_queue.queue_len;
  489. rxq_desc.fields.address = adapter->rx_queue.queue_dma;
  490. ibmveth_debug_printk("buffer list @ 0x%p\n", adapter->buffer_list_addr);
  491. ibmveth_debug_printk("filter list @ 0x%p\n", adapter->filter_list_addr);
  492. ibmveth_debug_printk("receive q @ 0x%p\n", adapter->rx_queue.queue_addr);
  493. h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
  494. lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
  495. if(lpar_rc != H_SUCCESS) {
  496. ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc);
  497. ibmveth_error_printk("buffer TCE:0x%llx filter TCE:0x%llx rxq desc:0x%llx MAC:0x%llx\n",
  498. adapter->buffer_list_dma,
  499. adapter->filter_list_dma,
  500. rxq_desc.desc,
  501. mac_address);
  502. ibmveth_cleanup(adapter);
  503. napi_disable(&adapter->napi);
  504. return -ENONET;
  505. }
  506. for(i = 0; i<IbmVethNumBufferPools; i++) {
  507. if(!adapter->rx_buff_pool[i].active)
  508. continue;
  509. if (ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[i])) {
  510. ibmveth_error_printk("unable to alloc pool\n");
  511. adapter->rx_buff_pool[i].active = 0;
  512. ibmveth_cleanup(adapter);
  513. napi_disable(&adapter->napi);
  514. return -ENOMEM ;
  515. }
  516. }
  517. ibmveth_debug_printk("registering irq 0x%x\n", netdev->irq);
  518. if((rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name, netdev)) != 0) {
  519. ibmveth_error_printk("unable to request irq 0x%x, rc %d\n", netdev->irq, rc);
  520. do {
  521. rc = h_free_logical_lan(adapter->vdev->unit_address);
  522. } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
  523. ibmveth_cleanup(adapter);
  524. napi_disable(&adapter->napi);
  525. return rc;
  526. }
  527. adapter->bounce_buffer =
  528. kmalloc(netdev->mtu + IBMVETH_BUFF_OH, GFP_KERNEL);
  529. if (!adapter->bounce_buffer) {
  530. ibmveth_error_printk("unable to allocate bounce buffer\n");
  531. ibmveth_cleanup(adapter);
  532. napi_disable(&adapter->napi);
  533. return -ENOMEM;
  534. }
  535. adapter->bounce_buffer_dma =
  536. dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer,
  537. netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL);
  538. if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
  539. ibmveth_error_printk("unable to map bounce buffer\n");
  540. ibmveth_cleanup(adapter);
  541. napi_disable(&adapter->napi);
  542. return -ENOMEM;
  543. }
  544. ibmveth_debug_printk("initial replenish cycle\n");
  545. ibmveth_interrupt(netdev->irq, netdev);
  546. netif_start_queue(netdev);
  547. ibmveth_debug_printk("open complete\n");
  548. return 0;
  549. }
  550. static int ibmveth_close(struct net_device *netdev)
  551. {
  552. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  553. long lpar_rc;
  554. ibmveth_debug_printk("close starting\n");
  555. napi_disable(&adapter->napi);
  556. if (!adapter->pool_config)
  557. netif_stop_queue(netdev);
  558. h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
  559. do {
  560. lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
  561. } while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
  562. if(lpar_rc != H_SUCCESS)
  563. {
  564. ibmveth_error_printk("h_free_logical_lan failed with %lx, continuing with close\n",
  565. lpar_rc);
  566. }
  567. free_irq(netdev->irq, netdev);
  568. adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
  569. ibmveth_cleanup(adapter);
  570. ibmveth_debug_printk("close complete\n");
  571. return 0;
  572. }
  573. static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) {
  574. cmd->supported = (SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg | SUPPORTED_FIBRE);
  575. cmd->advertising = (ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg | ADVERTISED_FIBRE);
  576. cmd->speed = SPEED_1000;
  577. cmd->duplex = DUPLEX_FULL;
  578. cmd->port = PORT_FIBRE;
  579. cmd->phy_address = 0;
  580. cmd->transceiver = XCVR_INTERNAL;
  581. cmd->autoneg = AUTONEG_ENABLE;
  582. cmd->maxtxpkt = 0;
  583. cmd->maxrxpkt = 1;
  584. return 0;
  585. }
  586. static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info) {
  587. strncpy(info->driver, ibmveth_driver_name, sizeof(info->driver) - 1);
  588. strncpy(info->version, ibmveth_driver_version, sizeof(info->version) - 1);
  589. }
  590. static u32 netdev_get_link(struct net_device *dev) {
  591. return 1;
  592. }
  593. static void ibmveth_set_rx_csum_flags(struct net_device *dev, u32 data)
  594. {
  595. struct ibmveth_adapter *adapter = netdev_priv(dev);
  596. if (data)
  597. adapter->rx_csum = 1;
  598. else {
  599. /*
  600. * Since the ibmveth firmware interface does not have the concept of
  601. * separate tx/rx checksum offload enable, if rx checksum is disabled
  602. * we also have to disable tx checksum offload. Once we disable rx
  603. * checksum offload, we are no longer allowed to send tx buffers that
  604. * are not properly checksummed.
  605. */
  606. adapter->rx_csum = 0;
  607. dev->features &= ~NETIF_F_IP_CSUM;
  608. }
  609. }
  610. static void ibmveth_set_tx_csum_flags(struct net_device *dev, u32 data)
  611. {
  612. struct ibmveth_adapter *adapter = netdev_priv(dev);
  613. if (data) {
  614. dev->features |= NETIF_F_IP_CSUM;
  615. adapter->rx_csum = 1;
  616. } else
  617. dev->features &= ~NETIF_F_IP_CSUM;
  618. }
  619. static int ibmveth_set_csum_offload(struct net_device *dev, u32 data,
  620. void (*done) (struct net_device *, u32))
  621. {
  622. struct ibmveth_adapter *adapter = netdev_priv(dev);
  623. unsigned long set_attr, clr_attr, ret_attr;
  624. long ret;
  625. int rc1 = 0, rc2 = 0;
  626. int restart = 0;
  627. if (netif_running(dev)) {
  628. restart = 1;
  629. adapter->pool_config = 1;
  630. ibmveth_close(dev);
  631. adapter->pool_config = 0;
  632. }
  633. set_attr = 0;
  634. clr_attr = 0;
  635. if (data)
  636. set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
  637. else
  638. clr_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
  639. ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
  640. if (ret == H_SUCCESS && !(ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK) &&
  641. !(ret_attr & IBMVETH_ILLAN_TRUNK_PRI_MASK) &&
  642. (ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
  643. ret = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
  644. set_attr, &ret_attr);
  645. if (ret != H_SUCCESS) {
  646. rc1 = -EIO;
  647. ibmveth_error_printk("unable to change checksum offload settings."
  648. " %d rc=%ld\n", data, ret);
  649. ret = h_illan_attributes(adapter->vdev->unit_address,
  650. set_attr, clr_attr, &ret_attr);
  651. } else
  652. done(dev, data);
  653. } else {
  654. rc1 = -EIO;
  655. ibmveth_error_printk("unable to change checksum offload settings."
  656. " %d rc=%ld ret_attr=%lx\n", data, ret, ret_attr);
  657. }
  658. if (restart)
  659. rc2 = ibmveth_open(dev);
  660. return rc1 ? rc1 : rc2;
  661. }
  662. static int ibmveth_set_rx_csum(struct net_device *dev, u32 data)
  663. {
  664. struct ibmveth_adapter *adapter = netdev_priv(dev);
  665. if ((data && adapter->rx_csum) || (!data && !adapter->rx_csum))
  666. return 0;
  667. return ibmveth_set_csum_offload(dev, data, ibmveth_set_rx_csum_flags);
  668. }
  669. static int ibmveth_set_tx_csum(struct net_device *dev, u32 data)
  670. {
  671. struct ibmveth_adapter *adapter = netdev_priv(dev);
  672. int rc = 0;
  673. if (data && (dev->features & NETIF_F_IP_CSUM))
  674. return 0;
  675. if (!data && !(dev->features & NETIF_F_IP_CSUM))
  676. return 0;
  677. if (data && !adapter->rx_csum)
  678. rc = ibmveth_set_csum_offload(dev, data, ibmveth_set_tx_csum_flags);
  679. else
  680. ibmveth_set_tx_csum_flags(dev, data);
  681. return rc;
  682. }
  683. static u32 ibmveth_get_rx_csum(struct net_device *dev)
  684. {
  685. struct ibmveth_adapter *adapter = netdev_priv(dev);
  686. return adapter->rx_csum;
  687. }
  688. static void ibmveth_get_strings(struct net_device *dev, u32 stringset, u8 *data)
  689. {
  690. int i;
  691. if (stringset != ETH_SS_STATS)
  692. return;
  693. for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++, data += ETH_GSTRING_LEN)
  694. memcpy(data, ibmveth_stats[i].name, ETH_GSTRING_LEN);
  695. }
  696. static int ibmveth_get_sset_count(struct net_device *dev, int sset)
  697. {
  698. switch (sset) {
  699. case ETH_SS_STATS:
  700. return ARRAY_SIZE(ibmveth_stats);
  701. default:
  702. return -EOPNOTSUPP;
  703. }
  704. }
  705. static void ibmveth_get_ethtool_stats(struct net_device *dev,
  706. struct ethtool_stats *stats, u64 *data)
  707. {
  708. int i;
  709. struct ibmveth_adapter *adapter = netdev_priv(dev);
  710. for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++)
  711. data[i] = IBMVETH_GET_STAT(adapter, ibmveth_stats[i].offset);
  712. }
  713. static const struct ethtool_ops netdev_ethtool_ops = {
  714. .get_drvinfo = netdev_get_drvinfo,
  715. .get_settings = netdev_get_settings,
  716. .get_link = netdev_get_link,
  717. .set_tx_csum = ibmveth_set_tx_csum,
  718. .get_rx_csum = ibmveth_get_rx_csum,
  719. .set_rx_csum = ibmveth_set_rx_csum,
  720. .get_strings = ibmveth_get_strings,
  721. .get_sset_count = ibmveth_get_sset_count,
  722. .get_ethtool_stats = ibmveth_get_ethtool_stats,
  723. };
  724. static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  725. {
  726. return -EOPNOTSUPP;
  727. }
  728. #define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
  729. static netdev_tx_t ibmveth_start_xmit(struct sk_buff *skb,
  730. struct net_device *netdev)
  731. {
  732. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  733. union ibmveth_buf_desc desc;
  734. unsigned long lpar_rc;
  735. unsigned long correlator;
  736. unsigned long flags;
  737. unsigned int retry_count;
  738. unsigned int tx_dropped = 0;
  739. unsigned int tx_bytes = 0;
  740. unsigned int tx_packets = 0;
  741. unsigned int tx_send_failed = 0;
  742. unsigned int tx_map_failed = 0;
  743. int used_bounce = 0;
  744. unsigned long data_dma_addr;
  745. desc.fields.flags_len = IBMVETH_BUF_VALID | skb->len;
  746. if (skb->ip_summed == CHECKSUM_PARTIAL &&
  747. ip_hdr(skb)->protocol != IPPROTO_TCP && skb_checksum_help(skb)) {
  748. ibmveth_error_printk("tx: failed to checksum packet\n");
  749. tx_dropped++;
  750. goto out;
  751. }
  752. if (skb->ip_summed == CHECKSUM_PARTIAL) {
  753. unsigned char *buf = skb_transport_header(skb) + skb->csum_offset;
  754. desc.fields.flags_len |= (IBMVETH_BUF_NO_CSUM | IBMVETH_BUF_CSUM_GOOD);
  755. /* Need to zero out the checksum */
  756. buf[0] = 0;
  757. buf[1] = 0;
  758. }
  759. data_dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
  760. skb->len, DMA_TO_DEVICE);
  761. if (dma_mapping_error(&adapter->vdev->dev, data_dma_addr)) {
  762. if (!firmware_has_feature(FW_FEATURE_CMO))
  763. ibmveth_error_printk("tx: unable to map xmit buffer\n");
  764. skb_copy_from_linear_data(skb, adapter->bounce_buffer,
  765. skb->len);
  766. desc.fields.address = adapter->bounce_buffer_dma;
  767. tx_map_failed++;
  768. used_bounce = 1;
  769. wmb();
  770. } else
  771. desc.fields.address = data_dma_addr;
  772. /* send the frame. Arbitrarily set retrycount to 1024 */
  773. correlator = 0;
  774. retry_count = 1024;
  775. do {
  776. lpar_rc = h_send_logical_lan(adapter->vdev->unit_address,
  777. desc.desc, 0, 0, 0, 0, 0,
  778. correlator, &correlator);
  779. } while ((lpar_rc == H_BUSY) && (retry_count--));
  780. if(lpar_rc != H_SUCCESS && lpar_rc != H_DROPPED) {
  781. ibmveth_error_printk("tx: h_send_logical_lan failed with rc=%ld\n", lpar_rc);
  782. ibmveth_error_printk("tx: valid=%d, len=%d, address=0x%08x\n",
  783. (desc.fields.flags_len & IBMVETH_BUF_VALID) ? 1 : 0,
  784. skb->len, desc.fields.address);
  785. tx_send_failed++;
  786. tx_dropped++;
  787. } else {
  788. tx_packets++;
  789. tx_bytes += skb->len;
  790. netdev->trans_start = jiffies; /* NETIF_F_LLTX driver :( */
  791. }
  792. if (!used_bounce)
  793. dma_unmap_single(&adapter->vdev->dev, data_dma_addr,
  794. skb->len, DMA_TO_DEVICE);
  795. out: spin_lock_irqsave(&adapter->stats_lock, flags);
  796. netdev->stats.tx_dropped += tx_dropped;
  797. netdev->stats.tx_bytes += tx_bytes;
  798. netdev->stats.tx_packets += tx_packets;
  799. adapter->tx_send_failed += tx_send_failed;
  800. adapter->tx_map_failed += tx_map_failed;
  801. spin_unlock_irqrestore(&adapter->stats_lock, flags);
  802. dev_kfree_skb(skb);
  803. return NETDEV_TX_OK;
  804. }
  805. static int ibmveth_poll(struct napi_struct *napi, int budget)
  806. {
  807. struct ibmveth_adapter *adapter = container_of(napi, struct ibmveth_adapter, napi);
  808. struct net_device *netdev = adapter->netdev;
  809. int frames_processed = 0;
  810. unsigned long lpar_rc;
  811. restart_poll:
  812. do {
  813. struct sk_buff *skb;
  814. if (!ibmveth_rxq_pending_buffer(adapter))
  815. break;
  816. rmb();
  817. if (!ibmveth_rxq_buffer_valid(adapter)) {
  818. wmb(); /* suggested by larson1 */
  819. adapter->rx_invalid_buffer++;
  820. ibmveth_debug_printk("recycling invalid buffer\n");
  821. ibmveth_rxq_recycle_buffer(adapter);
  822. } else {
  823. int length = ibmveth_rxq_frame_length(adapter);
  824. int offset = ibmveth_rxq_frame_offset(adapter);
  825. int csum_good = ibmveth_rxq_csum_good(adapter);
  826. skb = ibmveth_rxq_get_buffer(adapter);
  827. if (csum_good)
  828. skb->ip_summed = CHECKSUM_UNNECESSARY;
  829. ibmveth_rxq_harvest_buffer(adapter);
  830. skb_reserve(skb, offset);
  831. skb_put(skb, length);
  832. skb->protocol = eth_type_trans(skb, netdev);
  833. netif_receive_skb(skb); /* send it up */
  834. netdev->stats.rx_packets++;
  835. netdev->stats.rx_bytes += length;
  836. frames_processed++;
  837. }
  838. } while (frames_processed < budget);
  839. ibmveth_replenish_task(adapter);
  840. if (frames_processed < budget) {
  841. /* We think we are done - reenable interrupts,
  842. * then check once more to make sure we are done.
  843. */
  844. lpar_rc = h_vio_signal(adapter->vdev->unit_address,
  845. VIO_IRQ_ENABLE);
  846. ibmveth_assert(lpar_rc == H_SUCCESS);
  847. napi_complete(napi);
  848. if (ibmveth_rxq_pending_buffer(adapter) &&
  849. napi_reschedule(napi)) {
  850. lpar_rc = h_vio_signal(adapter->vdev->unit_address,
  851. VIO_IRQ_DISABLE);
  852. goto restart_poll;
  853. }
  854. }
  855. return frames_processed;
  856. }
  857. static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
  858. {
  859. struct net_device *netdev = dev_instance;
  860. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  861. unsigned long lpar_rc;
  862. if (napi_schedule_prep(&adapter->napi)) {
  863. lpar_rc = h_vio_signal(adapter->vdev->unit_address,
  864. VIO_IRQ_DISABLE);
  865. ibmveth_assert(lpar_rc == H_SUCCESS);
  866. __napi_schedule(&adapter->napi);
  867. }
  868. return IRQ_HANDLED;
  869. }
  870. static void ibmveth_set_multicast_list(struct net_device *netdev)
  871. {
  872. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  873. unsigned long lpar_rc;
  874. if ((netdev->flags & IFF_PROMISC) ||
  875. (netdev_mc_count(netdev) > adapter->mcastFilterSize)) {
  876. lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
  877. IbmVethMcastEnableRecv |
  878. IbmVethMcastDisableFiltering,
  879. 0);
  880. if(lpar_rc != H_SUCCESS) {
  881. ibmveth_error_printk("h_multicast_ctrl rc=%ld when entering promisc mode\n", lpar_rc);
  882. }
  883. } else {
  884. struct netdev_hw_addr *ha;
  885. /* clear the filter table & disable filtering */
  886. lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
  887. IbmVethMcastEnableRecv |
  888. IbmVethMcastDisableFiltering |
  889. IbmVethMcastClearFilterTable,
  890. 0);
  891. if(lpar_rc != H_SUCCESS) {
  892. ibmveth_error_printk("h_multicast_ctrl rc=%ld when attempting to clear filter table\n", lpar_rc);
  893. }
  894. /* add the addresses to the filter table */
  895. netdev_for_each_mc_addr(ha, netdev) {
  896. // add the multicast address to the filter table
  897. unsigned long mcast_addr = 0;
  898. memcpy(((char *)&mcast_addr)+2, ha->addr, 6);
  899. lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
  900. IbmVethMcastAddFilter,
  901. mcast_addr);
  902. if(lpar_rc != H_SUCCESS) {
  903. ibmveth_error_printk("h_multicast_ctrl rc=%ld when adding an entry to the filter table\n", lpar_rc);
  904. }
  905. }
  906. /* re-enable filtering */
  907. lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
  908. IbmVethMcastEnableFiltering,
  909. 0);
  910. if(lpar_rc != H_SUCCESS) {
  911. ibmveth_error_printk("h_multicast_ctrl rc=%ld when enabling filtering\n", lpar_rc);
  912. }
  913. }
  914. }
  915. static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
  916. {
  917. struct ibmveth_adapter *adapter = netdev_priv(dev);
  918. struct vio_dev *viodev = adapter->vdev;
  919. int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH;
  920. int i, rc;
  921. int need_restart = 0;
  922. if (new_mtu < IBMVETH_MAX_MTU)
  923. return -EINVAL;
  924. for (i = 0; i < IbmVethNumBufferPools; i++)
  925. if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size)
  926. break;
  927. if (i == IbmVethNumBufferPools)
  928. return -EINVAL;
  929. /* Deactivate all the buffer pools so that the next loop can activate
  930. only the buffer pools necessary to hold the new MTU */
  931. if (netif_running(adapter->netdev)) {
  932. need_restart = 1;
  933. adapter->pool_config = 1;
  934. ibmveth_close(adapter->netdev);
  935. adapter->pool_config = 0;
  936. }
  937. /* Look for an active buffer pool that can hold the new MTU */
  938. for(i = 0; i<IbmVethNumBufferPools; i++) {
  939. adapter->rx_buff_pool[i].active = 1;
  940. if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size) {
  941. dev->mtu = new_mtu;
  942. vio_cmo_set_dev_desired(viodev,
  943. ibmveth_get_desired_dma
  944. (viodev));
  945. if (need_restart) {
  946. return ibmveth_open(adapter->netdev);
  947. }
  948. return 0;
  949. }
  950. }
  951. if (need_restart && (rc = ibmveth_open(adapter->netdev)))
  952. return rc;
  953. return -EINVAL;
  954. }
  955. #ifdef CONFIG_NET_POLL_CONTROLLER
  956. static void ibmveth_poll_controller(struct net_device *dev)
  957. {
  958. ibmveth_replenish_task(netdev_priv(dev));
  959. ibmveth_interrupt(dev->irq, dev);
  960. }
  961. #endif
  962. /**
  963. * ibmveth_get_desired_dma - Calculate IO memory desired by the driver
  964. *
  965. * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
  966. *
  967. * Return value:
  968. * Number of bytes of IO data the driver will need to perform well.
  969. */
  970. static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev)
  971. {
  972. struct net_device *netdev = dev_get_drvdata(&vdev->dev);
  973. struct ibmveth_adapter *adapter;
  974. unsigned long ret;
  975. int i;
  976. int rxqentries = 1;
  977. /* netdev inits at probe time along with the structures we need below*/
  978. if (netdev == NULL)
  979. return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT);
  980. adapter = netdev_priv(netdev);
  981. ret = IBMVETH_BUFF_LIST_SIZE + IBMVETH_FILT_LIST_SIZE;
  982. ret += IOMMU_PAGE_ALIGN(netdev->mtu);
  983. for (i = 0; i < IbmVethNumBufferPools; i++) {
  984. /* add the size of the active receive buffers */
  985. if (adapter->rx_buff_pool[i].active)
  986. ret +=
  987. adapter->rx_buff_pool[i].size *
  988. IOMMU_PAGE_ALIGN(adapter->rx_buff_pool[i].
  989. buff_size);
  990. rxqentries += adapter->rx_buff_pool[i].size;
  991. }
  992. /* add the size of the receive queue entries */
  993. ret += IOMMU_PAGE_ALIGN(rxqentries * sizeof(struct ibmveth_rx_q_entry));
  994. return ret;
  995. }
  996. static const struct net_device_ops ibmveth_netdev_ops = {
  997. .ndo_open = ibmveth_open,
  998. .ndo_stop = ibmveth_close,
  999. .ndo_start_xmit = ibmveth_start_xmit,
  1000. .ndo_set_multicast_list = ibmveth_set_multicast_list,
  1001. .ndo_do_ioctl = ibmveth_ioctl,
  1002. .ndo_change_mtu = ibmveth_change_mtu,
  1003. .ndo_validate_addr = eth_validate_addr,
  1004. .ndo_set_mac_address = eth_mac_addr,
  1005. #ifdef CONFIG_NET_POLL_CONTROLLER
  1006. .ndo_poll_controller = ibmveth_poll_controller,
  1007. #endif
  1008. };
  1009. static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
  1010. {
  1011. int rc, i;
  1012. long ret;
  1013. struct net_device *netdev;
  1014. struct ibmveth_adapter *adapter;
  1015. unsigned long set_attr, ret_attr;
  1016. unsigned char *mac_addr_p;
  1017. unsigned int *mcastFilterSize_p;
  1018. ibmveth_debug_printk_no_adapter("entering ibmveth_probe for UA 0x%x\n",
  1019. dev->unit_address);
  1020. mac_addr_p = (unsigned char *) vio_get_attribute(dev,
  1021. VETH_MAC_ADDR, NULL);
  1022. if(!mac_addr_p) {
  1023. printk(KERN_ERR "(%s:%3.3d) ERROR: Can't find VETH_MAC_ADDR "
  1024. "attribute\n", __FILE__, __LINE__);
  1025. return 0;
  1026. }
  1027. mcastFilterSize_p = (unsigned int *) vio_get_attribute(dev,
  1028. VETH_MCAST_FILTER_SIZE, NULL);
  1029. if(!mcastFilterSize_p) {
  1030. printk(KERN_ERR "(%s:%3.3d) ERROR: Can't find "
  1031. "VETH_MCAST_FILTER_SIZE attribute\n",
  1032. __FILE__, __LINE__);
  1033. return 0;
  1034. }
  1035. netdev = alloc_etherdev(sizeof(struct ibmveth_adapter));
  1036. if(!netdev)
  1037. return -ENOMEM;
  1038. adapter = netdev_priv(netdev);
  1039. dev_set_drvdata(&dev->dev, netdev);
  1040. adapter->vdev = dev;
  1041. adapter->netdev = netdev;
  1042. adapter->mcastFilterSize= *mcastFilterSize_p;
  1043. adapter->pool_config = 0;
  1044. netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);
  1045. /* Some older boxes running PHYP non-natively have an OF that
  1046. returns a 8-byte local-mac-address field (and the first
  1047. 2 bytes have to be ignored) while newer boxes' OF return
  1048. a 6-byte field. Note that IEEE 1275 specifies that
  1049. local-mac-address must be a 6-byte field.
  1050. The RPA doc specifies that the first byte must be 10b, so
  1051. we'll just look for it to solve this 8 vs. 6 byte field issue */
  1052. if ((*mac_addr_p & 0x3) != 0x02)
  1053. mac_addr_p += 2;
  1054. adapter->mac_addr = 0;
  1055. memcpy(&adapter->mac_addr, mac_addr_p, 6);
  1056. netdev->irq = dev->irq;
  1057. netdev->netdev_ops = &ibmveth_netdev_ops;
  1058. netdev->ethtool_ops = &netdev_ethtool_ops;
  1059. SET_NETDEV_DEV(netdev, &dev->dev);
  1060. netdev->features |= NETIF_F_LLTX;
  1061. spin_lock_init(&adapter->stats_lock);
  1062. memcpy(netdev->dev_addr, &adapter->mac_addr, netdev->addr_len);
  1063. for(i = 0; i<IbmVethNumBufferPools; i++) {
  1064. struct kobject *kobj = &adapter->rx_buff_pool[i].kobj;
  1065. int error;
  1066. ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i,
  1067. pool_count[i], pool_size[i],
  1068. pool_active[i]);
  1069. error = kobject_init_and_add(kobj, &ktype_veth_pool,
  1070. &dev->dev.kobj, "pool%d", i);
  1071. if (!error)
  1072. kobject_uevent(kobj, KOBJ_ADD);
  1073. }
  1074. ibmveth_debug_printk("adapter @ 0x%p\n", adapter);
  1075. adapter->buffer_list_dma = DMA_ERROR_CODE;
  1076. adapter->filter_list_dma = DMA_ERROR_CODE;
  1077. adapter->rx_queue.queue_dma = DMA_ERROR_CODE;
  1078. ibmveth_debug_printk("registering netdev...\n");
  1079. ret = h_illan_attributes(dev->unit_address, 0, 0, &ret_attr);
  1080. if (ret == H_SUCCESS && !(ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK) &&
  1081. !(ret_attr & IBMVETH_ILLAN_TRUNK_PRI_MASK) &&
  1082. (ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
  1083. set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
  1084. ret = h_illan_attributes(dev->unit_address, 0, set_attr, &ret_attr);
  1085. if (ret == H_SUCCESS) {
  1086. adapter->rx_csum = 1;
  1087. netdev->features |= NETIF_F_IP_CSUM;
  1088. } else
  1089. ret = h_illan_attributes(dev->unit_address, set_attr, 0, &ret_attr);
  1090. }
  1091. rc = register_netdev(netdev);
  1092. if(rc) {
  1093. ibmveth_debug_printk("failed to register netdev rc=%d\n", rc);
  1094. free_netdev(netdev);
  1095. return rc;
  1096. }
  1097. ibmveth_debug_printk("registered\n");
  1098. ibmveth_proc_register_adapter(adapter);
  1099. return 0;
  1100. }
  1101. static int __devexit ibmveth_remove(struct vio_dev *dev)
  1102. {
  1103. struct net_device *netdev = dev_get_drvdata(&dev->dev);
  1104. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  1105. int i;
  1106. for(i = 0; i<IbmVethNumBufferPools; i++)
  1107. kobject_put(&adapter->rx_buff_pool[i].kobj);
  1108. unregister_netdev(netdev);
  1109. ibmveth_proc_unregister_adapter(adapter);
  1110. free_netdev(netdev);
  1111. dev_set_drvdata(&dev->dev, NULL);
  1112. return 0;
  1113. }
  1114. #ifdef CONFIG_PROC_FS
  1115. static void ibmveth_proc_register_driver(void)
  1116. {
  1117. ibmveth_proc_dir = proc_mkdir(IBMVETH_PROC_DIR, init_net.proc_net);
  1118. if (ibmveth_proc_dir) {
  1119. }
  1120. }
  1121. static void ibmveth_proc_unregister_driver(void)
  1122. {
  1123. remove_proc_entry(IBMVETH_PROC_DIR, init_net.proc_net);
  1124. }
  1125. static int ibmveth_show(struct seq_file *seq, void *v)
  1126. {
  1127. struct ibmveth_adapter *adapter = seq->private;
  1128. char *current_mac = (char *) adapter->netdev->dev_addr;
  1129. char *firmware_mac = (char *) &adapter->mac_addr;
  1130. seq_printf(seq, "%s %s\n\n", ibmveth_driver_string, ibmveth_driver_version);
  1131. seq_printf(seq, "Unit Address: 0x%x\n", adapter->vdev->unit_address);
  1132. seq_printf(seq, "Current MAC: %pM\n", current_mac);
  1133. seq_printf(seq, "Firmware MAC: %pM\n", firmware_mac);
  1134. seq_printf(seq, "\nAdapter Statistics:\n");
  1135. seq_printf(seq, " TX: vio_map_single failres: %lld\n", adapter->tx_map_failed);
  1136. seq_printf(seq, " send failures: %lld\n", adapter->tx_send_failed);
  1137. seq_printf(seq, " RX: replenish task cycles: %lld\n", adapter->replenish_task_cycles);
  1138. seq_printf(seq, " alloc_skb_failures: %lld\n", adapter->replenish_no_mem);
  1139. seq_printf(seq, " add buffer failures: %lld\n", adapter->replenish_add_buff_failure);
  1140. seq_printf(seq, " invalid buffers: %lld\n", adapter->rx_invalid_buffer);
  1141. seq_printf(seq, " no buffers: %lld\n", adapter->rx_no_buffer);
  1142. return 0;
  1143. }
  1144. static int ibmveth_proc_open(struct inode *inode, struct file *file)
  1145. {
  1146. return single_open(file, ibmveth_show, PDE(inode)->data);
  1147. }
  1148. static const struct file_operations ibmveth_proc_fops = {
  1149. .owner = THIS_MODULE,
  1150. .open = ibmveth_proc_open,
  1151. .read = seq_read,
  1152. .llseek = seq_lseek,
  1153. .release = single_release,
  1154. };
  1155. static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
  1156. {
  1157. struct proc_dir_entry *entry;
  1158. if (ibmveth_proc_dir) {
  1159. char u_addr[10];
  1160. sprintf(u_addr, "%x", adapter->vdev->unit_address);
  1161. entry = proc_create_data(u_addr, S_IFREG, ibmveth_proc_dir,
  1162. &ibmveth_proc_fops, adapter);
  1163. if (!entry)
  1164. ibmveth_error_printk("Cannot create adapter proc entry");
  1165. }
  1166. }
  1167. static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
  1168. {
  1169. if (ibmveth_proc_dir) {
  1170. char u_addr[10];
  1171. sprintf(u_addr, "%x", adapter->vdev->unit_address);
  1172. remove_proc_entry(u_addr, ibmveth_proc_dir);
  1173. }
  1174. }
  1175. #else /* CONFIG_PROC_FS */
  1176. static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
  1177. {
  1178. }
  1179. static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
  1180. {
  1181. }
  1182. static void ibmveth_proc_register_driver(void)
  1183. {
  1184. }
  1185. static void ibmveth_proc_unregister_driver(void)
  1186. {
  1187. }
  1188. #endif /* CONFIG_PROC_FS */
  1189. static struct attribute veth_active_attr;
  1190. static struct attribute veth_num_attr;
  1191. static struct attribute veth_size_attr;
  1192. static ssize_t veth_pool_show(struct kobject * kobj,
  1193. struct attribute * attr, char * buf)
  1194. {
  1195. struct ibmveth_buff_pool *pool = container_of(kobj,
  1196. struct ibmveth_buff_pool,
  1197. kobj);
  1198. if (attr == &veth_active_attr)
  1199. return sprintf(buf, "%d\n", pool->active);
  1200. else if (attr == &veth_num_attr)
  1201. return sprintf(buf, "%d\n", pool->size);
  1202. else if (attr == &veth_size_attr)
  1203. return sprintf(buf, "%d\n", pool->buff_size);
  1204. return 0;
  1205. }
  1206. static ssize_t veth_pool_store(struct kobject * kobj, struct attribute * attr,
  1207. const char * buf, size_t count)
  1208. {
  1209. struct ibmveth_buff_pool *pool = container_of(kobj,
  1210. struct ibmveth_buff_pool,
  1211. kobj);
  1212. struct net_device *netdev = dev_get_drvdata(
  1213. container_of(kobj->parent, struct device, kobj));
  1214. struct ibmveth_adapter *adapter = netdev_priv(netdev);
  1215. long value = simple_strtol(buf, NULL, 10);
  1216. long rc;
  1217. if (attr == &veth_active_attr) {
  1218. if (value && !pool->active) {
  1219. if (netif_running(netdev)) {
  1220. if(ibmveth_alloc_buffer_pool(pool)) {
  1221. ibmveth_error_printk("unable to alloc pool\n");
  1222. return -ENOMEM;
  1223. }
  1224. pool->active = 1;
  1225. adapter->pool_config = 1;
  1226. ibmveth_close(netdev);
  1227. adapter->pool_config = 0;
  1228. if ((rc = ibmveth_open(netdev)))
  1229. return rc;
  1230. } else
  1231. pool->active = 1;
  1232. } else if (!value && pool->active) {
  1233. int mtu = netdev->mtu + IBMVETH_BUFF_OH;
  1234. int i;
  1235. /* Make sure there is a buffer pool with buffers that
  1236. can hold a packet of the size of the MTU */
  1237. for (i = 0; i < IbmVethNumBufferPools; i++) {
  1238. if (pool == &adapter->rx_buff_pool[i])
  1239. continue;
  1240. if (!adapter->rx_buff_pool[i].active)
  1241. continue;
  1242. if (mtu <= adapter->rx_buff_pool[i].buff_size)
  1243. break;
  1244. }
  1245. if (i == IbmVethNumBufferPools) {
  1246. ibmveth_error_printk("no active pool >= MTU\n");
  1247. return -EPERM;
  1248. }
  1249. if (netif_running(netdev)) {
  1250. adapter->pool_config = 1;
  1251. ibmveth_close(netdev);
  1252. pool->active = 0;
  1253. adapter->pool_config = 0;
  1254. if ((rc = ibmveth_open(netdev)))
  1255. return rc;
  1256. }
  1257. pool->active = 0;
  1258. }
  1259. } else if (attr == &veth_num_attr) {
  1260. if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT)
  1261. return -EINVAL;
  1262. else {
  1263. if (netif_running(netdev)) {
  1264. adapter->pool_config = 1;
  1265. ibmveth_close(netdev);
  1266. adapter->pool_config = 0;
  1267. pool->size = value;
  1268. if ((rc = ibmveth_open(netdev)))
  1269. return rc;
  1270. } else
  1271. pool->size = value;
  1272. }
  1273. } else if (attr == &veth_size_attr) {
  1274. if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE)
  1275. return -EINVAL;
  1276. else {
  1277. if (netif_running(netdev)) {
  1278. adapter->pool_config = 1;
  1279. ibmveth_close(netdev);
  1280. adapter->pool_config = 0;
  1281. pool->buff_size = value;
  1282. if ((rc = ibmveth_open(netdev)))
  1283. return rc;
  1284. } else
  1285. pool->buff_size = value;
  1286. }
  1287. }
  1288. /* kick the interrupt handler to allocate/deallocate pools */
  1289. ibmveth_interrupt(netdev->irq, netdev);
  1290. return count;
  1291. }
  1292. #define ATTR(_name, _mode) \
  1293. struct attribute veth_##_name##_attr = { \
  1294. .name = __stringify(_name), .mode = _mode, \
  1295. };
  1296. static ATTR(active, 0644);
  1297. static ATTR(num, 0644);
  1298. static ATTR(size, 0644);
  1299. static struct attribute * veth_pool_attrs[] = {
  1300. &veth_active_attr,
  1301. &veth_num_attr,
  1302. &veth_size_attr,
  1303. NULL,
  1304. };
  1305. static const struct sysfs_ops veth_pool_ops = {
  1306. .show = veth_pool_show,
  1307. .store = veth_pool_store,
  1308. };
  1309. static struct kobj_type ktype_veth_pool = {
  1310. .release = NULL,
  1311. .sysfs_ops = &veth_pool_ops,
  1312. .default_attrs = veth_pool_attrs,
  1313. };
  1314. static int ibmveth_resume(struct device *dev)
  1315. {
  1316. struct net_device *netdev = dev_get_drvdata(dev);
  1317. ibmveth_interrupt(netdev->irq, netdev);
  1318. return 0;
  1319. }
  1320. static struct vio_device_id ibmveth_device_table[] __devinitdata= {
  1321. { "network", "IBM,l-lan"},
  1322. { "", "" }
  1323. };
  1324. MODULE_DEVICE_TABLE(vio, ibmveth_device_table);
  1325. static struct dev_pm_ops ibmveth_pm_ops = {
  1326. .resume = ibmveth_resume
  1327. };
  1328. static struct vio_driver ibmveth_driver = {
  1329. .id_table = ibmveth_device_table,
  1330. .probe = ibmveth_probe,
  1331. .remove = ibmveth_remove,
  1332. .get_desired_dma = ibmveth_get_desired_dma,
  1333. .driver = {
  1334. .name = ibmveth_driver_name,
  1335. .owner = THIS_MODULE,
  1336. .pm = &ibmveth_pm_ops,
  1337. }
  1338. };
  1339. static int __init ibmveth_module_init(void)
  1340. {
  1341. ibmveth_printk("%s: %s %s\n", ibmveth_driver_name, ibmveth_driver_string, ibmveth_driver_version);
  1342. ibmveth_proc_register_driver();
  1343. return vio_register_driver(&ibmveth_driver);
  1344. }
  1345. static void __exit ibmveth_module_exit(void)
  1346. {
  1347. vio_unregister_driver(&ibmveth_driver);
  1348. ibmveth_proc_unregister_driver();
  1349. }
  1350. module_init(ibmveth_module_init);
  1351. module_exit(ibmveth_module_exit);