fjes_main.c 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464
  1. /*
  2. * FUJITSU Extended Socket Network Device driver
  3. * Copyright (c) 2015 FUJITSU LIMITED
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms and conditions of the GNU General Public License,
  7. * version 2, as published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope it will be useful, but WITHOUT
  10. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12. * more details.
  13. *
  14. * You should have received a copy of the GNU General Public License along with
  15. * this program; if not, see <http://www.gnu.org/licenses/>.
  16. *
  17. * The full GNU General Public License is included in this distribution in
  18. * the file called "COPYING".
  19. *
  20. */
  21. #include <linux/module.h>
  22. #include <linux/types.h>
  23. #include <linux/nls.h>
  24. #include <linux/platform_device.h>
  25. #include <linux/netdevice.h>
  26. #include <linux/interrupt.h>
  27. #include "fjes.h"
  28. #define MAJ 1
  29. #define MIN 1
  30. #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN)
  31. #define DRV_NAME "fjes"
  32. char fjes_driver_name[] = DRV_NAME;
  33. char fjes_driver_version[] = DRV_VERSION;
  34. static const char fjes_driver_string[] =
  35. "FUJITSU Extended Socket Network Device Driver";
  36. static const char fjes_copyright[] =
  37. "Copyright (c) 2015 FUJITSU LIMITED";
  38. MODULE_AUTHOR("Taku Izumi <izumi.taku@jp.fujitsu.com>");
  39. MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver");
  40. MODULE_LICENSE("GPL");
  41. MODULE_VERSION(DRV_VERSION);
  42. static int fjes_request_irq(struct fjes_adapter *);
  43. static void fjes_free_irq(struct fjes_adapter *);
  44. static int fjes_open(struct net_device *);
  45. static int fjes_close(struct net_device *);
  46. static int fjes_setup_resources(struct fjes_adapter *);
  47. static void fjes_free_resources(struct fjes_adapter *);
  48. static netdev_tx_t fjes_xmit_frame(struct sk_buff *, struct net_device *);
  49. static void fjes_raise_intr_rxdata_task(struct work_struct *);
  50. static void fjes_tx_stall_task(struct work_struct *);
  51. static void fjes_force_close_task(struct work_struct *);
  52. static irqreturn_t fjes_intr(int, void*);
  53. static struct rtnl_link_stats64 *
  54. fjes_get_stats64(struct net_device *, struct rtnl_link_stats64 *);
  55. static int fjes_change_mtu(struct net_device *, int);
  56. static int fjes_vlan_rx_add_vid(struct net_device *, __be16 proto, u16);
  57. static int fjes_vlan_rx_kill_vid(struct net_device *, __be16 proto, u16);
  58. static void fjes_tx_retry(struct net_device *);
  59. static int fjes_acpi_add(struct acpi_device *);
  60. static int fjes_acpi_remove(struct acpi_device *);
  61. static acpi_status fjes_get_acpi_resource(struct acpi_resource *, void*);
  62. static int fjes_probe(struct platform_device *);
  63. static int fjes_remove(struct platform_device *);
  64. static int fjes_sw_init(struct fjes_adapter *);
  65. static void fjes_netdev_setup(struct net_device *);
  66. static void fjes_irq_watch_task(struct work_struct *);
  67. static void fjes_watch_unshare_task(struct work_struct *);
  68. static void fjes_rx_irq(struct fjes_adapter *, int);
  69. static int fjes_poll(struct napi_struct *, int);
  70. static const struct acpi_device_id fjes_acpi_ids[] = {
  71. {"PNP0C02", 0},
  72. {"", 0},
  73. };
  74. MODULE_DEVICE_TABLE(acpi, fjes_acpi_ids);
  75. static struct acpi_driver fjes_acpi_driver = {
  76. .name = DRV_NAME,
  77. .class = DRV_NAME,
  78. .owner = THIS_MODULE,
  79. .ids = fjes_acpi_ids,
  80. .ops = {
  81. .add = fjes_acpi_add,
  82. .remove = fjes_acpi_remove,
  83. },
  84. };
  85. static struct platform_driver fjes_driver = {
  86. .driver = {
  87. .name = DRV_NAME,
  88. },
  89. .probe = fjes_probe,
  90. .remove = fjes_remove,
  91. };
  92. static struct resource fjes_resource[] = {
  93. {
  94. .flags = IORESOURCE_MEM,
  95. .start = 0,
  96. .end = 0,
  97. },
  98. {
  99. .flags = IORESOURCE_IRQ,
  100. .start = 0,
  101. .end = 0,
  102. },
  103. };
  104. static int fjes_acpi_add(struct acpi_device *device)
  105. {
  106. struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
  107. char str_buf[sizeof(FJES_ACPI_SYMBOL) + 1];
  108. struct platform_device *plat_dev;
  109. union acpi_object *str;
  110. acpi_status status;
  111. int result;
  112. status = acpi_evaluate_object(device->handle, "_STR", NULL, &buffer);
  113. if (ACPI_FAILURE(status))
  114. return -ENODEV;
  115. str = buffer.pointer;
  116. result = utf16s_to_utf8s((wchar_t *)str->string.pointer,
  117. str->string.length, UTF16_LITTLE_ENDIAN,
  118. str_buf, sizeof(str_buf) - 1);
  119. str_buf[result] = 0;
  120. if (strncmp(FJES_ACPI_SYMBOL, str_buf, strlen(FJES_ACPI_SYMBOL)) != 0) {
  121. kfree(buffer.pointer);
  122. return -ENODEV;
  123. }
  124. kfree(buffer.pointer);
  125. status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
  126. fjes_get_acpi_resource, fjes_resource);
  127. if (ACPI_FAILURE(status))
  128. return -ENODEV;
  129. /* create platform_device */
  130. plat_dev = platform_device_register_simple(DRV_NAME, 0, fjes_resource,
  131. ARRAY_SIZE(fjes_resource));
  132. device->driver_data = plat_dev;
  133. return 0;
  134. }
  135. static int fjes_acpi_remove(struct acpi_device *device)
  136. {
  137. struct platform_device *plat_dev;
  138. plat_dev = (struct platform_device *)acpi_driver_data(device);
  139. platform_device_unregister(plat_dev);
  140. return 0;
  141. }
  142. static acpi_status
  143. fjes_get_acpi_resource(struct acpi_resource *acpi_res, void *data)
  144. {
  145. struct acpi_resource_address32 *addr;
  146. struct acpi_resource_irq *irq;
  147. struct resource *res = data;
  148. switch (acpi_res->type) {
  149. case ACPI_RESOURCE_TYPE_ADDRESS32:
  150. addr = &acpi_res->data.address32;
  151. res[0].start = addr->address.minimum;
  152. res[0].end = addr->address.minimum +
  153. addr->address.address_length - 1;
  154. break;
  155. case ACPI_RESOURCE_TYPE_IRQ:
  156. irq = &acpi_res->data.irq;
  157. if (irq->interrupt_count != 1)
  158. return AE_ERROR;
  159. res[1].start = irq->interrupts[0];
  160. res[1].end = irq->interrupts[0];
  161. break;
  162. default:
  163. break;
  164. }
  165. return AE_OK;
  166. }
  167. static int fjes_request_irq(struct fjes_adapter *adapter)
  168. {
  169. struct net_device *netdev = adapter->netdev;
  170. int result = -1;
  171. adapter->interrupt_watch_enable = true;
  172. if (!delayed_work_pending(&adapter->interrupt_watch_task)) {
  173. queue_delayed_work(adapter->control_wq,
  174. &adapter->interrupt_watch_task,
  175. FJES_IRQ_WATCH_DELAY);
  176. }
  177. if (!adapter->irq_registered) {
  178. result = request_irq(adapter->hw.hw_res.irq, fjes_intr,
  179. IRQF_SHARED, netdev->name, adapter);
  180. if (result)
  181. adapter->irq_registered = false;
  182. else
  183. adapter->irq_registered = true;
  184. }
  185. return result;
  186. }
  187. static void fjes_free_irq(struct fjes_adapter *adapter)
  188. {
  189. struct fjes_hw *hw = &adapter->hw;
  190. adapter->interrupt_watch_enable = false;
  191. cancel_delayed_work_sync(&adapter->interrupt_watch_task);
  192. fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, true);
  193. if (adapter->irq_registered) {
  194. free_irq(adapter->hw.hw_res.irq, adapter);
  195. adapter->irq_registered = false;
  196. }
  197. }
  198. static const struct net_device_ops fjes_netdev_ops = {
  199. .ndo_open = fjes_open,
  200. .ndo_stop = fjes_close,
  201. .ndo_start_xmit = fjes_xmit_frame,
  202. .ndo_get_stats64 = fjes_get_stats64,
  203. .ndo_change_mtu = fjes_change_mtu,
  204. .ndo_tx_timeout = fjes_tx_retry,
  205. .ndo_vlan_rx_add_vid = fjes_vlan_rx_add_vid,
  206. .ndo_vlan_rx_kill_vid = fjes_vlan_rx_kill_vid,
  207. };
  208. /* fjes_open - Called when a network interface is made active */
  209. static int fjes_open(struct net_device *netdev)
  210. {
  211. struct fjes_adapter *adapter = netdev_priv(netdev);
  212. struct fjes_hw *hw = &adapter->hw;
  213. int result;
  214. if (adapter->open_guard)
  215. return -ENXIO;
  216. result = fjes_setup_resources(adapter);
  217. if (result)
  218. goto err_setup_res;
  219. hw->txrx_stop_req_bit = 0;
  220. hw->epstop_req_bit = 0;
  221. napi_enable(&adapter->napi);
  222. fjes_hw_capture_interrupt_status(hw);
  223. result = fjes_request_irq(adapter);
  224. if (result)
  225. goto err_req_irq;
  226. fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, false);
  227. netif_tx_start_all_queues(netdev);
  228. netif_carrier_on(netdev);
  229. return 0;
  230. err_req_irq:
  231. fjes_free_irq(adapter);
  232. napi_disable(&adapter->napi);
  233. err_setup_res:
  234. fjes_free_resources(adapter);
  235. return result;
  236. }
  237. /* fjes_close - Disables a network interface */
  238. static int fjes_close(struct net_device *netdev)
  239. {
  240. struct fjes_adapter *adapter = netdev_priv(netdev);
  241. struct fjes_hw *hw = &adapter->hw;
  242. unsigned long flags;
  243. int epidx;
  244. netif_tx_stop_all_queues(netdev);
  245. netif_carrier_off(netdev);
  246. fjes_hw_raise_epstop(hw);
  247. napi_disable(&adapter->napi);
  248. spin_lock_irqsave(&hw->rx_status_lock, flags);
  249. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  250. if (epidx == hw->my_epid)
  251. continue;
  252. if (fjes_hw_get_partner_ep_status(hw, epidx) ==
  253. EP_PARTNER_SHARED)
  254. adapter->hw.ep_shm_info[epidx]
  255. .tx.info->v1i.rx_status &=
  256. ~FJES_RX_POLL_WORK;
  257. }
  258. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  259. fjes_free_irq(adapter);
  260. cancel_delayed_work_sync(&adapter->interrupt_watch_task);
  261. cancel_work_sync(&adapter->unshare_watch_task);
  262. adapter->unshare_watch_bitmask = 0;
  263. cancel_work_sync(&adapter->raise_intr_rxdata_task);
  264. cancel_work_sync(&adapter->tx_stall_task);
  265. cancel_work_sync(&hw->update_zone_task);
  266. cancel_work_sync(&hw->epstop_task);
  267. fjes_hw_wait_epstop(hw);
  268. fjes_free_resources(adapter);
  269. return 0;
  270. }
  271. static int fjes_setup_resources(struct fjes_adapter *adapter)
  272. {
  273. struct net_device *netdev = adapter->netdev;
  274. struct ep_share_mem_info *buf_pair;
  275. struct fjes_hw *hw = &adapter->hw;
  276. unsigned long flags;
  277. int result;
  278. int epidx;
  279. mutex_lock(&hw->hw_info.lock);
  280. result = fjes_hw_request_info(hw);
  281. switch (result) {
  282. case 0:
  283. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  284. hw->ep_shm_info[epidx].es_status =
  285. hw->hw_info.res_buf->info.info[epidx].es_status;
  286. hw->ep_shm_info[epidx].zone =
  287. hw->hw_info.res_buf->info.info[epidx].zone;
  288. }
  289. break;
  290. default:
  291. case -ENOMSG:
  292. case -EBUSY:
  293. adapter->force_reset = true;
  294. mutex_unlock(&hw->hw_info.lock);
  295. return result;
  296. }
  297. mutex_unlock(&hw->hw_info.lock);
  298. for (epidx = 0; epidx < (hw->max_epid); epidx++) {
  299. if ((epidx != hw->my_epid) &&
  300. (hw->ep_shm_info[epidx].es_status ==
  301. FJES_ZONING_STATUS_ENABLE)) {
  302. fjes_hw_raise_interrupt(hw, epidx,
  303. REG_ICTL_MASK_INFO_UPDATE);
  304. }
  305. }
  306. msleep(FJES_OPEN_ZONE_UPDATE_WAIT * hw->max_epid);
  307. for (epidx = 0; epidx < (hw->max_epid); epidx++) {
  308. if (epidx == hw->my_epid)
  309. continue;
  310. buf_pair = &hw->ep_shm_info[epidx];
  311. spin_lock_irqsave(&hw->rx_status_lock, flags);
  312. fjes_hw_setup_epbuf(&buf_pair->tx, netdev->dev_addr,
  313. netdev->mtu);
  314. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  315. if (fjes_hw_epid_is_same_zone(hw, epidx)) {
  316. mutex_lock(&hw->hw_info.lock);
  317. result =
  318. fjes_hw_register_buff_addr(hw, epidx, buf_pair);
  319. mutex_unlock(&hw->hw_info.lock);
  320. switch (result) {
  321. case 0:
  322. break;
  323. case -ENOMSG:
  324. case -EBUSY:
  325. default:
  326. adapter->force_reset = true;
  327. return result;
  328. }
  329. }
  330. }
  331. return 0;
  332. }
  333. static void fjes_free_resources(struct fjes_adapter *adapter)
  334. {
  335. struct net_device *netdev = adapter->netdev;
  336. struct fjes_device_command_param param;
  337. struct ep_share_mem_info *buf_pair;
  338. struct fjes_hw *hw = &adapter->hw;
  339. bool reset_flag = false;
  340. unsigned long flags;
  341. int result;
  342. int epidx;
  343. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  344. if (epidx == hw->my_epid)
  345. continue;
  346. mutex_lock(&hw->hw_info.lock);
  347. result = fjes_hw_unregister_buff_addr(hw, epidx);
  348. mutex_unlock(&hw->hw_info.lock);
  349. if (result)
  350. reset_flag = true;
  351. buf_pair = &hw->ep_shm_info[epidx];
  352. spin_lock_irqsave(&hw->rx_status_lock, flags);
  353. fjes_hw_setup_epbuf(&buf_pair->tx,
  354. netdev->dev_addr, netdev->mtu);
  355. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  356. clear_bit(epidx, &hw->txrx_stop_req_bit);
  357. }
  358. if (reset_flag || adapter->force_reset) {
  359. result = fjes_hw_reset(hw);
  360. adapter->force_reset = false;
  361. if (result)
  362. adapter->open_guard = true;
  363. hw->hw_info.buffer_share_bit = 0;
  364. memset((void *)&param, 0, sizeof(param));
  365. param.req_len = hw->hw_info.req_buf_size;
  366. param.req_start = __pa(hw->hw_info.req_buf);
  367. param.res_len = hw->hw_info.res_buf_size;
  368. param.res_start = __pa(hw->hw_info.res_buf);
  369. param.share_start = __pa(hw->hw_info.share->ep_status);
  370. fjes_hw_init_command_registers(hw, &param);
  371. }
  372. }
  373. static void fjes_tx_stall_task(struct work_struct *work)
  374. {
  375. struct fjes_adapter *adapter = container_of(work,
  376. struct fjes_adapter, tx_stall_task);
  377. struct net_device *netdev = adapter->netdev;
  378. struct fjes_hw *hw = &adapter->hw;
  379. int all_queue_available, sendable;
  380. enum ep_partner_status pstatus;
  381. int max_epid, my_epid, epid;
  382. union ep_buffer_info *info;
  383. int i;
  384. if (((long)jiffies -
  385. dev_trans_start(netdev)) > FJES_TX_TX_STALL_TIMEOUT) {
  386. netif_wake_queue(netdev);
  387. return;
  388. }
  389. my_epid = hw->my_epid;
  390. max_epid = hw->max_epid;
  391. for (i = 0; i < 5; i++) {
  392. all_queue_available = 1;
  393. for (epid = 0; epid < max_epid; epid++) {
  394. if (my_epid == epid)
  395. continue;
  396. pstatus = fjes_hw_get_partner_ep_status(hw, epid);
  397. sendable = (pstatus == EP_PARTNER_SHARED);
  398. if (!sendable)
  399. continue;
  400. info = adapter->hw.ep_shm_info[epid].tx.info;
  401. if (!(info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE))
  402. return;
  403. if (EP_RING_FULL(info->v1i.head, info->v1i.tail,
  404. info->v1i.count_max)) {
  405. all_queue_available = 0;
  406. break;
  407. }
  408. }
  409. if (all_queue_available) {
  410. netif_wake_queue(netdev);
  411. return;
  412. }
  413. }
  414. usleep_range(50, 100);
  415. queue_work(adapter->txrx_wq, &adapter->tx_stall_task);
  416. }
  417. static void fjes_force_close_task(struct work_struct *work)
  418. {
  419. struct fjes_adapter *adapter = container_of(work,
  420. struct fjes_adapter, force_close_task);
  421. struct net_device *netdev = adapter->netdev;
  422. rtnl_lock();
  423. dev_close(netdev);
  424. rtnl_unlock();
  425. }
  426. static void fjes_raise_intr_rxdata_task(struct work_struct *work)
  427. {
  428. struct fjes_adapter *adapter = container_of(work,
  429. struct fjes_adapter, raise_intr_rxdata_task);
  430. struct fjes_hw *hw = &adapter->hw;
  431. enum ep_partner_status pstatus;
  432. int max_epid, my_epid, epid;
  433. my_epid = hw->my_epid;
  434. max_epid = hw->max_epid;
  435. for (epid = 0; epid < max_epid; epid++)
  436. hw->ep_shm_info[epid].tx_status_work = 0;
  437. for (epid = 0; epid < max_epid; epid++) {
  438. if (epid == my_epid)
  439. continue;
  440. pstatus = fjes_hw_get_partner_ep_status(hw, epid);
  441. if (pstatus == EP_PARTNER_SHARED) {
  442. hw->ep_shm_info[epid].tx_status_work =
  443. hw->ep_shm_info[epid].tx.info->v1i.tx_status;
  444. if (hw->ep_shm_info[epid].tx_status_work ==
  445. FJES_TX_DELAY_SEND_PENDING) {
  446. hw->ep_shm_info[epid].tx.info->v1i.tx_status =
  447. FJES_TX_DELAY_SEND_NONE;
  448. }
  449. }
  450. }
  451. for (epid = 0; epid < max_epid; epid++) {
  452. if (epid == my_epid)
  453. continue;
  454. pstatus = fjes_hw_get_partner_ep_status(hw, epid);
  455. if ((hw->ep_shm_info[epid].tx_status_work ==
  456. FJES_TX_DELAY_SEND_PENDING) &&
  457. (pstatus == EP_PARTNER_SHARED) &&
  458. !(hw->ep_shm_info[epid].rx.info->v1i.rx_status &
  459. FJES_RX_POLL_WORK)) {
  460. fjes_hw_raise_interrupt(hw, epid,
  461. REG_ICTL_MASK_RX_DATA);
  462. }
  463. }
  464. usleep_range(500, 1000);
  465. }
  466. static int fjes_tx_send(struct fjes_adapter *adapter, int dest,
  467. void *data, size_t len)
  468. {
  469. int retval;
  470. retval = fjes_hw_epbuf_tx_pkt_send(&adapter->hw.ep_shm_info[dest].tx,
  471. data, len);
  472. if (retval)
  473. return retval;
  474. adapter->hw.ep_shm_info[dest].tx.info->v1i.tx_status =
  475. FJES_TX_DELAY_SEND_PENDING;
  476. if (!work_pending(&adapter->raise_intr_rxdata_task))
  477. queue_work(adapter->txrx_wq,
  478. &adapter->raise_intr_rxdata_task);
  479. retval = 0;
  480. return retval;
  481. }
  482. static netdev_tx_t
  483. fjes_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
  484. {
  485. struct fjes_adapter *adapter = netdev_priv(netdev);
  486. struct fjes_hw *hw = &adapter->hw;
  487. int max_epid, my_epid, dest_epid;
  488. enum ep_partner_status pstatus;
  489. struct netdev_queue *cur_queue;
  490. char shortpkt[VLAN_ETH_HLEN];
  491. bool is_multi, vlan;
  492. struct ethhdr *eth;
  493. u16 queue_no = 0;
  494. u16 vlan_id = 0;
  495. netdev_tx_t ret;
  496. char *data;
  497. int len;
  498. ret = NETDEV_TX_OK;
  499. is_multi = false;
  500. cur_queue = netdev_get_tx_queue(netdev, queue_no);
  501. eth = (struct ethhdr *)skb->data;
  502. my_epid = hw->my_epid;
  503. vlan = (vlan_get_tag(skb, &vlan_id) == 0) ? true : false;
  504. data = skb->data;
  505. len = skb->len;
  506. if (is_multicast_ether_addr(eth->h_dest)) {
  507. dest_epid = 0;
  508. max_epid = hw->max_epid;
  509. is_multi = true;
  510. } else if (is_local_ether_addr(eth->h_dest)) {
  511. dest_epid = eth->h_dest[ETH_ALEN - 1];
  512. max_epid = dest_epid + 1;
  513. if ((eth->h_dest[0] == 0x02) &&
  514. (0x00 == (eth->h_dest[1] | eth->h_dest[2] |
  515. eth->h_dest[3] | eth->h_dest[4])) &&
  516. (dest_epid < hw->max_epid)) {
  517. ;
  518. } else {
  519. dest_epid = 0;
  520. max_epid = 0;
  521. ret = NETDEV_TX_OK;
  522. adapter->stats64.tx_packets += 1;
  523. hw->ep_shm_info[my_epid].net_stats.tx_packets += 1;
  524. adapter->stats64.tx_bytes += len;
  525. hw->ep_shm_info[my_epid].net_stats.tx_bytes += len;
  526. }
  527. } else {
  528. dest_epid = 0;
  529. max_epid = 0;
  530. ret = NETDEV_TX_OK;
  531. adapter->stats64.tx_packets += 1;
  532. hw->ep_shm_info[my_epid].net_stats.tx_packets += 1;
  533. adapter->stats64.tx_bytes += len;
  534. hw->ep_shm_info[my_epid].net_stats.tx_bytes += len;
  535. }
  536. for (; dest_epid < max_epid; dest_epid++) {
  537. if (my_epid == dest_epid)
  538. continue;
  539. pstatus = fjes_hw_get_partner_ep_status(hw, dest_epid);
  540. if (pstatus != EP_PARTNER_SHARED) {
  541. ret = NETDEV_TX_OK;
  542. } else if (!fjes_hw_check_epbuf_version(
  543. &adapter->hw.ep_shm_info[dest_epid].rx, 0)) {
  544. /* version is NOT 0 */
  545. adapter->stats64.tx_carrier_errors += 1;
  546. hw->ep_shm_info[dest_epid].net_stats
  547. .tx_carrier_errors += 1;
  548. ret = NETDEV_TX_OK;
  549. } else if (!fjes_hw_check_mtu(
  550. &adapter->hw.ep_shm_info[dest_epid].rx,
  551. netdev->mtu)) {
  552. adapter->stats64.tx_dropped += 1;
  553. hw->ep_shm_info[dest_epid].net_stats.tx_dropped += 1;
  554. adapter->stats64.tx_errors += 1;
  555. hw->ep_shm_info[dest_epid].net_stats.tx_errors += 1;
  556. ret = NETDEV_TX_OK;
  557. } else if (vlan &&
  558. !fjes_hw_check_vlan_id(
  559. &adapter->hw.ep_shm_info[dest_epid].rx,
  560. vlan_id)) {
  561. ret = NETDEV_TX_OK;
  562. } else {
  563. if (len < VLAN_ETH_HLEN) {
  564. memset(shortpkt, 0, VLAN_ETH_HLEN);
  565. memcpy(shortpkt, skb->data, skb->len);
  566. len = VLAN_ETH_HLEN;
  567. data = shortpkt;
  568. }
  569. if (adapter->tx_retry_count == 0) {
  570. adapter->tx_start_jiffies = jiffies;
  571. adapter->tx_retry_count = 1;
  572. } else {
  573. adapter->tx_retry_count++;
  574. }
  575. if (fjes_tx_send(adapter, dest_epid, data, len)) {
  576. if (is_multi) {
  577. ret = NETDEV_TX_OK;
  578. } else if (
  579. ((long)jiffies -
  580. (long)adapter->tx_start_jiffies) >=
  581. FJES_TX_RETRY_TIMEOUT) {
  582. adapter->stats64.tx_fifo_errors += 1;
  583. hw->ep_shm_info[dest_epid].net_stats
  584. .tx_fifo_errors += 1;
  585. adapter->stats64.tx_errors += 1;
  586. hw->ep_shm_info[dest_epid].net_stats
  587. .tx_errors += 1;
  588. ret = NETDEV_TX_OK;
  589. } else {
  590. netif_trans_update(netdev);
  591. netif_tx_stop_queue(cur_queue);
  592. if (!work_pending(&adapter->tx_stall_task))
  593. queue_work(adapter->txrx_wq,
  594. &adapter->tx_stall_task);
  595. ret = NETDEV_TX_BUSY;
  596. }
  597. } else {
  598. if (!is_multi) {
  599. adapter->stats64.tx_packets += 1;
  600. hw->ep_shm_info[dest_epid].net_stats
  601. .tx_packets += 1;
  602. adapter->stats64.tx_bytes += len;
  603. hw->ep_shm_info[dest_epid].net_stats
  604. .tx_bytes += len;
  605. }
  606. adapter->tx_retry_count = 0;
  607. ret = NETDEV_TX_OK;
  608. }
  609. }
  610. }
  611. if (ret == NETDEV_TX_OK) {
  612. dev_kfree_skb(skb);
  613. if (is_multi) {
  614. adapter->stats64.tx_packets += 1;
  615. hw->ep_shm_info[my_epid].net_stats.tx_packets += 1;
  616. adapter->stats64.tx_bytes += 1;
  617. hw->ep_shm_info[my_epid].net_stats.tx_bytes += len;
  618. }
  619. }
  620. return ret;
  621. }
  622. static void fjes_tx_retry(struct net_device *netdev)
  623. {
  624. struct netdev_queue *queue = netdev_get_tx_queue(netdev, 0);
  625. netif_tx_wake_queue(queue);
  626. }
  627. static struct rtnl_link_stats64 *
  628. fjes_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
  629. {
  630. struct fjes_adapter *adapter = netdev_priv(netdev);
  631. memcpy(stats, &adapter->stats64, sizeof(struct rtnl_link_stats64));
  632. return stats;
  633. }
  634. static int fjes_change_mtu(struct net_device *netdev, int new_mtu)
  635. {
  636. struct fjes_adapter *adapter = netdev_priv(netdev);
  637. bool running = netif_running(netdev);
  638. struct fjes_hw *hw = &adapter->hw;
  639. unsigned long flags;
  640. int ret = -EINVAL;
  641. int idx, epidx;
  642. for (idx = 0; fjes_support_mtu[idx] != 0; idx++) {
  643. if (new_mtu <= fjes_support_mtu[idx]) {
  644. new_mtu = fjes_support_mtu[idx];
  645. if (new_mtu == netdev->mtu)
  646. return 0;
  647. ret = 0;
  648. break;
  649. }
  650. }
  651. if (ret)
  652. return ret;
  653. if (running) {
  654. spin_lock_irqsave(&hw->rx_status_lock, flags);
  655. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  656. if (epidx == hw->my_epid)
  657. continue;
  658. hw->ep_shm_info[epidx].tx.info->v1i.rx_status &=
  659. ~FJES_RX_MTU_CHANGING_DONE;
  660. }
  661. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  662. netif_tx_stop_all_queues(netdev);
  663. netif_carrier_off(netdev);
  664. cancel_work_sync(&adapter->tx_stall_task);
  665. napi_disable(&adapter->napi);
  666. msleep(1000);
  667. netif_tx_stop_all_queues(netdev);
  668. }
  669. netdev->mtu = new_mtu;
  670. if (running) {
  671. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  672. if (epidx == hw->my_epid)
  673. continue;
  674. spin_lock_irqsave(&hw->rx_status_lock, flags);
  675. fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx,
  676. netdev->dev_addr,
  677. netdev->mtu);
  678. hw->ep_shm_info[epidx].tx.info->v1i.rx_status |=
  679. FJES_RX_MTU_CHANGING_DONE;
  680. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  681. }
  682. netif_tx_wake_all_queues(netdev);
  683. netif_carrier_on(netdev);
  684. napi_enable(&adapter->napi);
  685. napi_schedule(&adapter->napi);
  686. }
  687. return ret;
  688. }
  689. static int fjes_vlan_rx_add_vid(struct net_device *netdev,
  690. __be16 proto, u16 vid)
  691. {
  692. struct fjes_adapter *adapter = netdev_priv(netdev);
  693. bool ret = true;
  694. int epid;
  695. for (epid = 0; epid < adapter->hw.max_epid; epid++) {
  696. if (epid == adapter->hw.my_epid)
  697. continue;
  698. if (!fjes_hw_check_vlan_id(
  699. &adapter->hw.ep_shm_info[epid].tx, vid))
  700. ret = fjes_hw_set_vlan_id(
  701. &adapter->hw.ep_shm_info[epid].tx, vid);
  702. }
  703. return ret ? 0 : -ENOSPC;
  704. }
  705. static int fjes_vlan_rx_kill_vid(struct net_device *netdev,
  706. __be16 proto, u16 vid)
  707. {
  708. struct fjes_adapter *adapter = netdev_priv(netdev);
  709. int epid;
  710. for (epid = 0; epid < adapter->hw.max_epid; epid++) {
  711. if (epid == adapter->hw.my_epid)
  712. continue;
  713. fjes_hw_del_vlan_id(&adapter->hw.ep_shm_info[epid].tx, vid);
  714. }
  715. return 0;
  716. }
  717. static void fjes_txrx_stop_req_irq(struct fjes_adapter *adapter,
  718. int src_epid)
  719. {
  720. struct fjes_hw *hw = &adapter->hw;
  721. enum ep_partner_status status;
  722. unsigned long flags;
  723. status = fjes_hw_get_partner_ep_status(hw, src_epid);
  724. switch (status) {
  725. case EP_PARTNER_UNSHARE:
  726. case EP_PARTNER_COMPLETE:
  727. default:
  728. break;
  729. case EP_PARTNER_WAITING:
  730. if (src_epid < hw->my_epid) {
  731. spin_lock_irqsave(&hw->rx_status_lock, flags);
  732. hw->ep_shm_info[src_epid].tx.info->v1i.rx_status |=
  733. FJES_RX_STOP_REQ_DONE;
  734. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  735. clear_bit(src_epid, &hw->txrx_stop_req_bit);
  736. set_bit(src_epid, &adapter->unshare_watch_bitmask);
  737. if (!work_pending(&adapter->unshare_watch_task))
  738. queue_work(adapter->control_wq,
  739. &adapter->unshare_watch_task);
  740. }
  741. break;
  742. case EP_PARTNER_SHARED:
  743. if (hw->ep_shm_info[src_epid].rx.info->v1i.rx_status &
  744. FJES_RX_STOP_REQ_REQUEST) {
  745. set_bit(src_epid, &hw->epstop_req_bit);
  746. if (!work_pending(&hw->epstop_task))
  747. queue_work(adapter->control_wq,
  748. &hw->epstop_task);
  749. }
  750. break;
  751. }
  752. }
  753. static void fjes_stop_req_irq(struct fjes_adapter *adapter, int src_epid)
  754. {
  755. struct fjes_hw *hw = &adapter->hw;
  756. enum ep_partner_status status;
  757. unsigned long flags;
  758. set_bit(src_epid, &hw->hw_info.buffer_unshare_reserve_bit);
  759. status = fjes_hw_get_partner_ep_status(hw, src_epid);
  760. switch (status) {
  761. case EP_PARTNER_WAITING:
  762. spin_lock_irqsave(&hw->rx_status_lock, flags);
  763. hw->ep_shm_info[src_epid].tx.info->v1i.rx_status |=
  764. FJES_RX_STOP_REQ_DONE;
  765. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  766. clear_bit(src_epid, &hw->txrx_stop_req_bit);
  767. /* fall through */
  768. case EP_PARTNER_UNSHARE:
  769. case EP_PARTNER_COMPLETE:
  770. default:
  771. set_bit(src_epid, &adapter->unshare_watch_bitmask);
  772. if (!work_pending(&adapter->unshare_watch_task))
  773. queue_work(adapter->control_wq,
  774. &adapter->unshare_watch_task);
  775. break;
  776. case EP_PARTNER_SHARED:
  777. set_bit(src_epid, &hw->epstop_req_bit);
  778. if (!work_pending(&hw->epstop_task))
  779. queue_work(adapter->control_wq, &hw->epstop_task);
  780. break;
  781. }
  782. }
  783. static void fjes_update_zone_irq(struct fjes_adapter *adapter,
  784. int src_epid)
  785. {
  786. struct fjes_hw *hw = &adapter->hw;
  787. if (!work_pending(&hw->update_zone_task))
  788. queue_work(adapter->control_wq, &hw->update_zone_task);
  789. }
  790. static irqreturn_t fjes_intr(int irq, void *data)
  791. {
  792. struct fjes_adapter *adapter = data;
  793. struct fjes_hw *hw = &adapter->hw;
  794. irqreturn_t ret;
  795. u32 icr;
  796. icr = fjes_hw_capture_interrupt_status(hw);
  797. if (icr & REG_IS_MASK_IS_ASSERT) {
  798. if (icr & REG_ICTL_MASK_RX_DATA)
  799. fjes_rx_irq(adapter, icr & REG_IS_MASK_EPID);
  800. if (icr & REG_ICTL_MASK_DEV_STOP_REQ)
  801. fjes_stop_req_irq(adapter, icr & REG_IS_MASK_EPID);
  802. if (icr & REG_ICTL_MASK_TXRX_STOP_REQ)
  803. fjes_txrx_stop_req_irq(adapter, icr & REG_IS_MASK_EPID);
  804. if (icr & REG_ICTL_MASK_TXRX_STOP_DONE)
  805. fjes_hw_set_irqmask(hw,
  806. REG_ICTL_MASK_TXRX_STOP_DONE, true);
  807. if (icr & REG_ICTL_MASK_INFO_UPDATE)
  808. fjes_update_zone_irq(adapter, icr & REG_IS_MASK_EPID);
  809. ret = IRQ_HANDLED;
  810. } else {
  811. ret = IRQ_NONE;
  812. }
  813. return ret;
  814. }
  815. static int fjes_rxframe_search_exist(struct fjes_adapter *adapter,
  816. int start_epid)
  817. {
  818. struct fjes_hw *hw = &adapter->hw;
  819. enum ep_partner_status pstatus;
  820. int max_epid, cur_epid;
  821. int i;
  822. max_epid = hw->max_epid;
  823. start_epid = (start_epid + 1 + max_epid) % max_epid;
  824. for (i = 0; i < max_epid; i++) {
  825. cur_epid = (start_epid + i) % max_epid;
  826. if (cur_epid == hw->my_epid)
  827. continue;
  828. pstatus = fjes_hw_get_partner_ep_status(hw, cur_epid);
  829. if (pstatus == EP_PARTNER_SHARED) {
  830. if (!fjes_hw_epbuf_rx_is_empty(
  831. &hw->ep_shm_info[cur_epid].rx))
  832. return cur_epid;
  833. }
  834. }
  835. return -1;
  836. }
  837. static void *fjes_rxframe_get(struct fjes_adapter *adapter, size_t *psize,
  838. int *cur_epid)
  839. {
  840. void *frame;
  841. *cur_epid = fjes_rxframe_search_exist(adapter, *cur_epid);
  842. if (*cur_epid < 0)
  843. return NULL;
  844. frame =
  845. fjes_hw_epbuf_rx_curpkt_get_addr(
  846. &adapter->hw.ep_shm_info[*cur_epid].rx, psize);
  847. return frame;
  848. }
  849. static void fjes_rxframe_release(struct fjes_adapter *adapter, int cur_epid)
  850. {
  851. fjes_hw_epbuf_rx_curpkt_drop(&adapter->hw.ep_shm_info[cur_epid].rx);
  852. }
  853. static void fjes_rx_irq(struct fjes_adapter *adapter, int src_epid)
  854. {
  855. struct fjes_hw *hw = &adapter->hw;
  856. fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, true);
  857. adapter->unset_rx_last = true;
  858. napi_schedule(&adapter->napi);
  859. }
  860. static int fjes_poll(struct napi_struct *napi, int budget)
  861. {
  862. struct fjes_adapter *adapter =
  863. container_of(napi, struct fjes_adapter, napi);
  864. struct net_device *netdev = napi->dev;
  865. struct fjes_hw *hw = &adapter->hw;
  866. struct sk_buff *skb;
  867. int work_done = 0;
  868. int cur_epid = 0;
  869. int epidx;
  870. size_t frame_len;
  871. void *frame;
  872. spin_lock(&hw->rx_status_lock);
  873. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  874. if (epidx == hw->my_epid)
  875. continue;
  876. if (fjes_hw_get_partner_ep_status(hw, epidx) ==
  877. EP_PARTNER_SHARED)
  878. adapter->hw.ep_shm_info[epidx]
  879. .tx.info->v1i.rx_status |= FJES_RX_POLL_WORK;
  880. }
  881. spin_unlock(&hw->rx_status_lock);
  882. while (work_done < budget) {
  883. prefetch(&adapter->hw);
  884. frame = fjes_rxframe_get(adapter, &frame_len, &cur_epid);
  885. if (frame) {
  886. skb = napi_alloc_skb(napi, frame_len);
  887. if (!skb) {
  888. adapter->stats64.rx_dropped += 1;
  889. hw->ep_shm_info[cur_epid].net_stats
  890. .rx_dropped += 1;
  891. adapter->stats64.rx_errors += 1;
  892. hw->ep_shm_info[cur_epid].net_stats
  893. .rx_errors += 1;
  894. } else {
  895. memcpy(skb_put(skb, frame_len),
  896. frame, frame_len);
  897. skb->protocol = eth_type_trans(skb, netdev);
  898. skb->ip_summed = CHECKSUM_UNNECESSARY;
  899. netif_receive_skb(skb);
  900. work_done++;
  901. adapter->stats64.rx_packets += 1;
  902. hw->ep_shm_info[cur_epid].net_stats
  903. .rx_packets += 1;
  904. adapter->stats64.rx_bytes += frame_len;
  905. hw->ep_shm_info[cur_epid].net_stats
  906. .rx_bytes += frame_len;
  907. if (is_multicast_ether_addr(
  908. ((struct ethhdr *)frame)->h_dest)) {
  909. adapter->stats64.multicast += 1;
  910. hw->ep_shm_info[cur_epid].net_stats
  911. .multicast += 1;
  912. }
  913. }
  914. fjes_rxframe_release(adapter, cur_epid);
  915. adapter->unset_rx_last = true;
  916. } else {
  917. break;
  918. }
  919. }
  920. if (work_done < budget) {
  921. napi_complete(napi);
  922. if (adapter->unset_rx_last) {
  923. adapter->rx_last_jiffies = jiffies;
  924. adapter->unset_rx_last = false;
  925. }
  926. if (((long)jiffies - (long)adapter->rx_last_jiffies) < 3) {
  927. napi_reschedule(napi);
  928. } else {
  929. spin_lock(&hw->rx_status_lock);
  930. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  931. if (epidx == hw->my_epid)
  932. continue;
  933. if (fjes_hw_get_partner_ep_status(hw, epidx) ==
  934. EP_PARTNER_SHARED)
  935. adapter->hw.ep_shm_info[epidx].tx
  936. .info->v1i.rx_status &=
  937. ~FJES_RX_POLL_WORK;
  938. }
  939. spin_unlock(&hw->rx_status_lock);
  940. fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, false);
  941. }
  942. }
  943. return work_done;
  944. }
  945. /* fjes_probe - Device Initialization Routine */
  946. static int fjes_probe(struct platform_device *plat_dev)
  947. {
  948. struct fjes_adapter *adapter;
  949. struct net_device *netdev;
  950. struct resource *res;
  951. struct fjes_hw *hw;
  952. int err;
  953. err = -ENOMEM;
  954. netdev = alloc_netdev_mq(sizeof(struct fjes_adapter), "es%d",
  955. NET_NAME_UNKNOWN, fjes_netdev_setup,
  956. FJES_MAX_QUEUES);
  957. if (!netdev)
  958. goto err_out;
  959. SET_NETDEV_DEV(netdev, &plat_dev->dev);
  960. dev_set_drvdata(&plat_dev->dev, netdev);
  961. adapter = netdev_priv(netdev);
  962. adapter->netdev = netdev;
  963. adapter->plat_dev = plat_dev;
  964. hw = &adapter->hw;
  965. hw->back = adapter;
  966. /* setup the private structure */
  967. err = fjes_sw_init(adapter);
  968. if (err)
  969. goto err_free_netdev;
  970. INIT_WORK(&adapter->force_close_task, fjes_force_close_task);
  971. adapter->force_reset = false;
  972. adapter->open_guard = false;
  973. adapter->txrx_wq = alloc_workqueue(DRV_NAME "/txrx", WQ_MEM_RECLAIM, 0);
  974. adapter->control_wq = alloc_workqueue(DRV_NAME "/control",
  975. WQ_MEM_RECLAIM, 0);
  976. INIT_WORK(&adapter->tx_stall_task, fjes_tx_stall_task);
  977. INIT_WORK(&adapter->raise_intr_rxdata_task,
  978. fjes_raise_intr_rxdata_task);
  979. INIT_WORK(&adapter->unshare_watch_task, fjes_watch_unshare_task);
  980. adapter->unshare_watch_bitmask = 0;
  981. INIT_DELAYED_WORK(&adapter->interrupt_watch_task, fjes_irq_watch_task);
  982. adapter->interrupt_watch_enable = false;
  983. res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0);
  984. hw->hw_res.start = res->start;
  985. hw->hw_res.size = resource_size(res);
  986. hw->hw_res.irq = platform_get_irq(plat_dev, 0);
  987. err = fjes_hw_init(&adapter->hw);
  988. if (err)
  989. goto err_free_netdev;
  990. /* setup MAC address (02:00:00:00:00:[epid])*/
  991. netdev->dev_addr[0] = 2;
  992. netdev->dev_addr[1] = 0;
  993. netdev->dev_addr[2] = 0;
  994. netdev->dev_addr[3] = 0;
  995. netdev->dev_addr[4] = 0;
  996. netdev->dev_addr[5] = hw->my_epid; /* EPID */
  997. err = register_netdev(netdev);
  998. if (err)
  999. goto err_hw_exit;
  1000. netif_carrier_off(netdev);
  1001. return 0;
  1002. err_hw_exit:
  1003. fjes_hw_exit(&adapter->hw);
  1004. err_free_netdev:
  1005. free_netdev(netdev);
  1006. err_out:
  1007. return err;
  1008. }
  1009. /* fjes_remove - Device Removal Routine */
  1010. static int fjes_remove(struct platform_device *plat_dev)
  1011. {
  1012. struct net_device *netdev = dev_get_drvdata(&plat_dev->dev);
  1013. struct fjes_adapter *adapter = netdev_priv(netdev);
  1014. struct fjes_hw *hw = &adapter->hw;
  1015. cancel_delayed_work_sync(&adapter->interrupt_watch_task);
  1016. cancel_work_sync(&adapter->unshare_watch_task);
  1017. cancel_work_sync(&adapter->raise_intr_rxdata_task);
  1018. cancel_work_sync(&adapter->tx_stall_task);
  1019. if (adapter->control_wq)
  1020. destroy_workqueue(adapter->control_wq);
  1021. if (adapter->txrx_wq)
  1022. destroy_workqueue(adapter->txrx_wq);
  1023. unregister_netdev(netdev);
  1024. fjes_hw_exit(hw);
  1025. netif_napi_del(&adapter->napi);
  1026. free_netdev(netdev);
  1027. return 0;
  1028. }
  1029. static int fjes_sw_init(struct fjes_adapter *adapter)
  1030. {
  1031. struct net_device *netdev = adapter->netdev;
  1032. netif_napi_add(netdev, &adapter->napi, fjes_poll, 64);
  1033. return 0;
  1034. }
  1035. /* fjes_netdev_setup - netdevice initialization routine */
  1036. static void fjes_netdev_setup(struct net_device *netdev)
  1037. {
  1038. ether_setup(netdev);
  1039. netdev->watchdog_timeo = FJES_TX_RETRY_INTERVAL;
  1040. netdev->netdev_ops = &fjes_netdev_ops;
  1041. fjes_set_ethtool_ops(netdev);
  1042. netdev->mtu = fjes_support_mtu[3];
  1043. netdev->flags |= IFF_BROADCAST;
  1044. netdev->features |= NETIF_F_HW_CSUM | NETIF_F_HW_VLAN_CTAG_FILTER;
  1045. }
  1046. static void fjes_irq_watch_task(struct work_struct *work)
  1047. {
  1048. struct fjes_adapter *adapter = container_of(to_delayed_work(work),
  1049. struct fjes_adapter, interrupt_watch_task);
  1050. local_irq_disable();
  1051. fjes_intr(adapter->hw.hw_res.irq, adapter);
  1052. local_irq_enable();
  1053. if (fjes_rxframe_search_exist(adapter, 0) >= 0)
  1054. napi_schedule(&adapter->napi);
  1055. if (adapter->interrupt_watch_enable) {
  1056. if (!delayed_work_pending(&adapter->interrupt_watch_task))
  1057. queue_delayed_work(adapter->control_wq,
  1058. &adapter->interrupt_watch_task,
  1059. FJES_IRQ_WATCH_DELAY);
  1060. }
  1061. }
  1062. static void fjes_watch_unshare_task(struct work_struct *work)
  1063. {
  1064. struct fjes_adapter *adapter =
  1065. container_of(work, struct fjes_adapter, unshare_watch_task);
  1066. struct net_device *netdev = adapter->netdev;
  1067. struct fjes_hw *hw = &adapter->hw;
  1068. int unshare_watch, unshare_reserve;
  1069. int max_epid, my_epid, epidx;
  1070. int stop_req, stop_req_done;
  1071. ulong unshare_watch_bitmask;
  1072. unsigned long flags;
  1073. int wait_time = 0;
  1074. int is_shared;
  1075. int ret;
  1076. my_epid = hw->my_epid;
  1077. max_epid = hw->max_epid;
  1078. unshare_watch_bitmask = adapter->unshare_watch_bitmask;
  1079. adapter->unshare_watch_bitmask = 0;
  1080. while ((unshare_watch_bitmask || hw->txrx_stop_req_bit) &&
  1081. (wait_time < 3000)) {
  1082. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  1083. if (epidx == hw->my_epid)
  1084. continue;
  1085. is_shared = fjes_hw_epid_is_shared(hw->hw_info.share,
  1086. epidx);
  1087. stop_req = test_bit(epidx, &hw->txrx_stop_req_bit);
  1088. stop_req_done = hw->ep_shm_info[epidx].rx.info->v1i.rx_status &
  1089. FJES_RX_STOP_REQ_DONE;
  1090. unshare_watch = test_bit(epidx, &unshare_watch_bitmask);
  1091. unshare_reserve = test_bit(epidx,
  1092. &hw->hw_info.buffer_unshare_reserve_bit);
  1093. if ((!stop_req ||
  1094. (is_shared && (!is_shared || !stop_req_done))) &&
  1095. (is_shared || !unshare_watch || !unshare_reserve))
  1096. continue;
  1097. mutex_lock(&hw->hw_info.lock);
  1098. ret = fjes_hw_unregister_buff_addr(hw, epidx);
  1099. switch (ret) {
  1100. case 0:
  1101. break;
  1102. case -ENOMSG:
  1103. case -EBUSY:
  1104. default:
  1105. if (!work_pending(
  1106. &adapter->force_close_task)) {
  1107. adapter->force_reset = true;
  1108. schedule_work(
  1109. &adapter->force_close_task);
  1110. }
  1111. break;
  1112. }
  1113. mutex_unlock(&hw->hw_info.lock);
  1114. spin_lock_irqsave(&hw->rx_status_lock, flags);
  1115. fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx,
  1116. netdev->dev_addr, netdev->mtu);
  1117. spin_unlock_irqrestore(&hw->rx_status_lock, flags);
  1118. clear_bit(epidx, &hw->txrx_stop_req_bit);
  1119. clear_bit(epidx, &unshare_watch_bitmask);
  1120. clear_bit(epidx,
  1121. &hw->hw_info.buffer_unshare_reserve_bit);
  1122. }
  1123. msleep(100);
  1124. wait_time += 100;
  1125. }
  1126. if (hw->hw_info.buffer_unshare_reserve_bit) {
  1127. for (epidx = 0; epidx < hw->max_epid; epidx++) {
  1128. if (epidx == hw->my_epid)
  1129. continue;
  1130. if (test_bit(epidx,
  1131. &hw->hw_info.buffer_unshare_reserve_bit)) {
  1132. mutex_lock(&hw->hw_info.lock);
  1133. ret = fjes_hw_unregister_buff_addr(hw, epidx);
  1134. switch (ret) {
  1135. case 0:
  1136. break;
  1137. case -ENOMSG:
  1138. case -EBUSY:
  1139. default:
  1140. if (!work_pending(
  1141. &adapter->force_close_task)) {
  1142. adapter->force_reset = true;
  1143. schedule_work(
  1144. &adapter->force_close_task);
  1145. }
  1146. break;
  1147. }
  1148. mutex_unlock(&hw->hw_info.lock);
  1149. spin_lock_irqsave(&hw->rx_status_lock, flags);
  1150. fjes_hw_setup_epbuf(
  1151. &hw->ep_shm_info[epidx].tx,
  1152. netdev->dev_addr, netdev->mtu);
  1153. spin_unlock_irqrestore(&hw->rx_status_lock,
  1154. flags);
  1155. clear_bit(epidx, &hw->txrx_stop_req_bit);
  1156. clear_bit(epidx, &unshare_watch_bitmask);
  1157. clear_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit);
  1158. }
  1159. if (test_bit(epidx, &unshare_watch_bitmask)) {
  1160. spin_lock_irqsave(&hw->rx_status_lock, flags);
  1161. hw->ep_shm_info[epidx].tx.info->v1i.rx_status &=
  1162. ~FJES_RX_STOP_REQ_DONE;
  1163. spin_unlock_irqrestore(&hw->rx_status_lock,
  1164. flags);
  1165. }
  1166. }
  1167. }
  1168. }
  1169. /* fjes_init_module - Driver Registration Routine */
  1170. static int __init fjes_init_module(void)
  1171. {
  1172. int result;
  1173. pr_info("%s - version %s - %s\n",
  1174. fjes_driver_string, fjes_driver_version, fjes_copyright);
  1175. result = platform_driver_register(&fjes_driver);
  1176. if (result < 0)
  1177. return result;
  1178. result = acpi_bus_register_driver(&fjes_acpi_driver);
  1179. if (result < 0)
  1180. goto fail_acpi_driver;
  1181. return 0;
  1182. fail_acpi_driver:
  1183. platform_driver_unregister(&fjes_driver);
  1184. return result;
  1185. }
  1186. module_init(fjes_init_module);
  1187. /* fjes_exit_module - Driver Exit Cleanup Routine */
  1188. static void __exit fjes_exit_module(void)
  1189. {
  1190. acpi_bus_unregister_driver(&fjes_acpi_driver);
  1191. platform_driver_unregister(&fjes_driver);
  1192. }
  1193. module_exit(fjes_exit_module);