开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sonic.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

sonic.c：源码内容
  1. /*
  2.  * sonic.c
  3.  *
  4.  * (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
  5.  * 
  6.  * This driver is based on work from Andreas Busse, but most of
  7.  * the code is rewritten.
  8.  * 
  9.  * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
  10.  *
  11.  *    Core code included by system sonic drivers
  12.  */
  14. /*
  15.  * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
  16.  * National Semiconductors data sheet for the DP83932B Sonic Ethernet
  17.  * controller, and the files "8390.c" and "skeleton.c" in this directory.
  18.  */
  22. /*
  23.  * Open/initialize the SONIC controller.
  24.  *
  25.  * This routine should set everything up anew at each open, even
  26.  *  registers that "should" only need to be set once at boot, so that
  27.  *  there is non-reboot way to recover if something goes wrong.
  28.  */
  29. static int sonic_open(struct net_device *dev)
  30. {
  31. if (sonic_debug > 2)
  32. printk("sonic_open: initializing sonic driver.n");
  34. /*
  35.  * We don't need to deal with auto-irq stuff since we
  36.  * hardwire the sonic interrupt.
  37.  */
  38. /*
  39.  * XXX Horrible work around:  We install sonic_interrupt as fast interrupt.
  40.  * This means that during execution of the handler interrupt are disabled
  41.  * covering another bug otherwise corrupting data.  This doesn't mean
  42.  * this glue works ok under all situations.
  43.  */
  44. //    if (sonic_request_irq(dev->irq, &sonic_interrupt, 0, "sonic", dev)) {
  45. if (sonic_request_irq(dev->irq, &sonic_interrupt, SA_INTERRUPT,
  46.                       "sonic", dev)) {
  47. printk("n%s: unable to get IRQ %d .n", dev->name, dev->irq);
  48. return -EAGAIN;
  49. }
  51. /*
  52.  * Initialize the SONIC
  53.  */
  54. sonic_init(dev);
  56. netif_start_queue(dev);
  58. if (sonic_debug > 2)
  59. printk("sonic_open: Initialization done.n");
  61. return 0;
  62. }
  65. /*
  66.  * Close the SONIC device
  67.  */
  68. static int sonic_close(struct net_device *dev)
  69. {
  70. unsigned int base_addr = dev->base_addr;
  72. if (sonic_debug > 2)
  73. printk("sonic_closen");
  75. netif_stop_queue(dev);
  77. /*
  78.  * stop the SONIC, disable interrupts
  79.  */
  80. SONIC_WRITE(SONIC_ISR, 0x7fff);
  81. SONIC_WRITE(SONIC_IMR, 0);
  82. SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
  84. sonic_free_irq(dev->irq, dev); /* release the IRQ */
  86. return 0;
  87. }
  89. static void sonic_tx_timeout(struct net_device *dev)
  90. {
  91. struct sonic_local *lp = (struct sonic_local *) dev->priv;
  92. printk("%s: transmit timed out.n", dev->name);
  94. /* Try to restart the adaptor. */
  95. sonic_init(dev);
  96. lp->stats.tx_errors++;
  97. dev->trans_start = jiffies;
  98. netif_wake_queue(dev);
  99. }
  101. /*
  102.  * transmit packet
  103.  */
  104. static int sonic_send_packet(struct sk_buff *skb, struct net_device *dev)
  105. {
  106. struct sonic_local *lp = (struct sonic_local *) dev->priv;
  107. unsigned int base_addr = dev->base_addr;
  108. unsigned int laddr;
  109. int entry, length;
  111. netif_stop_queue(dev);
  113. if (sonic_debug > 2)
  114. printk("sonic_send_packet: skb=%p, dev=%pn", skb, dev);
  116. /* 
  117.  * Block a timer-based transmit from overlapping.  This could better be
  118.  * done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
  119.  */
  120. if (test_and_set_bit(0, (void *) &dev->tbusy) != 0) {
  121. printk("%s: Transmitter access conflict.n", dev->name);
  122. return 1;
  123. }
  125. /*
  126.  * Map the packet data into the logical DMA address space
  127.  */
  128. if ((laddr = vdma_alloc(PHYSADDR(skb->data), skb->len)) == ~0UL) {
  129. printk("%s: no VDMA entry for transmit available.n",
  130.        dev->name);
  131. dev_kfree_skb(skb);
  132. netif_start_queue(dev);
  133. return 1;
  134. }
  135. entry = lp->cur_tx & SONIC_TDS_MASK;
  136. lp->tx_laddr[entry] = laddr;
  137. lp->tx_skb[entry] = skb;
  139. length = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
  140. flush_cache_all();
  142. /*
  143.  * Setup the transmit descriptor and issue the transmit command.
  144.  */
  145. lp->tda[entry].tx_status = 0; /* clear status */
  146. lp->tda[entry].tx_frag_count = 1; /* single fragment */
  147. lp->tda[entry].tx_pktsize = length; /* length of packet */
  148. lp->tda[entry].tx_frag_ptr_l = laddr & 0xffff;
  149. lp->tda[entry].tx_frag_ptr_h = laddr >> 16;
  150. lp->tda[entry].tx_frag_size = length;
  151. lp->cur_tx++;
  152. lp->stats.tx_bytes += length;
  154. if (sonic_debug > 2)
  155. printk("sonic_send_packet: issueing Tx commandn");
  157. SONIC_WRITE(SONIC_CMD, SONIC_CR_TXP);
  159. dev->trans_start = jiffies;
  161. if (lp->cur_tx < lp->dirty_tx + SONIC_NUM_TDS)
  162. netif_start_queue(dev);
  163. else
  164. lp->tx_full = 1;
  166. return 0;
  167. }
  169. /*
  170.  * The typical workload of the driver:
  171.  * Handle the network interface interrupts.
  172.  */
  173. static void sonic_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  174. {
  175. struct net_device *dev = (struct net_device *) dev_id;
  176. unsigned int base_addr = dev->base_addr;
  177. struct sonic_local *lp;
  178. int status;
  180. if (dev == NULL) {
  181. printk("sonic_interrupt: irq %d for unknown device.n", irq);
  182. return;
  183. }
  185. lp = (struct sonic_local *) dev->priv;
  187. status = SONIC_READ(SONIC_ISR);
  188. SONIC_WRITE(SONIC_ISR, 0x7fff); /* clear all bits */
  190. if (sonic_debug > 2)
  191. printk("sonic_interrupt: ISR=%xn", status);
  193. if (status & SONIC_INT_PKTRX) {
  194. sonic_rx(dev); /* got packet(s) */
  195. }
  197. if (status & SONIC_INT_TXDN) {
  198. int dirty_tx = lp->dirty_tx;
  200. while (dirty_tx < lp->cur_tx) {
  201. int entry = dirty_tx & SONIC_TDS_MASK;
  202. int status = lp->tda[entry].tx_status;
  204. if (sonic_debug > 3)
  205. printk
  206.     ("sonic_interrupt: status %d, cur_tx %d, dirty_tx %dn",
  207.      status, lp->cur_tx, lp->dirty_tx);
  209. if (status == 0) {
  210. /* It still hasn't been Txed, kick the sonic again */
  211. SONIC_WRITE(SONIC_CMD, SONIC_CR_TXP);
  212. break;
  213. }
  215. /* put back EOL and free descriptor */
  216. lp->tda[entry].tx_frag_count = 0;
  217. lp->tda[entry].tx_status = 0;
  219. if (status & 0x0001)
  220. lp->stats.tx_packets++;
  221. else {
  222. lp->stats.tx_errors++;
  223. if (status & 0x0642)
  224. lp->stats.tx_aborted_errors++;
  225. if (status & 0x0180)
  226. lp->stats.tx_carrier_errors++;
  227. if (status & 0x0020)
  228. lp->stats.tx_window_errors++;
  229. if (status & 0x0004)
  230. lp->stats.tx_fifo_errors++;
  231. }
  233. /* We must free the original skb */
  234. if (lp->tx_skb[entry]) {
  235. dev_kfree_skb(lp->tx_skb[entry]);
  236. lp->tx_skb[entry] = 0;
  237. }
  238. /* and the VDMA address */
  239. vdma_free(lp->tx_laddr[entry]);
  240. dirty_tx++;
  241. }
  243. if (lp->tx_full
  244.     && dirty_tx + SONIC_NUM_TDS > lp->cur_tx + 2) {
  245. /* The ring is no longer full, clear tbusy. */
  246. lp->tx_full = 0;
  247. netif_wake_queue(dev);
  248. }
  250. lp->dirty_tx = dirty_tx;
  251. }
  253. /*
  254.  * check error conditions
  255.  */
  256. if (status & SONIC_INT_RFO) {
  257. printk("%s: receive fifo underrunn", dev->name);
  258. lp->stats.rx_fifo_errors++;
  259. }
  260. if (status & SONIC_INT_RDE) {
  261. printk("%s: receive descriptors exhaustedn", dev->name);
  262. lp->stats.rx_dropped++;
  263. }
  264. if (status & SONIC_INT_RBE) {
  265. printk("%s: receive buffer exhaustedn", dev->name);
  266. lp->stats.rx_dropped++;
  267. }
  268. if (status & SONIC_INT_RBAE) {
  269. printk("%s: receive buffer area exhaustedn", dev->name);
  270. lp->stats.rx_dropped++;
  271. }
  273. /* counter overruns; all counters are 16bit wide */
  274. if (status & SONIC_INT_FAE)
  275. lp->stats.rx_frame_errors += 65536;
  276. if (status & SONIC_INT_CRC)
  277. lp->stats.rx_crc_errors += 65536;
  278. if (status & SONIC_INT_MP)
  279. lp->stats.rx_missed_errors += 65536;
  281. /* transmit error */
  282. if (status & SONIC_INT_TXER)
  283. lp->stats.tx_errors++;
  285. /*
  286.  * clear interrupt bits and return
  287.  */
  288. SONIC_WRITE(SONIC_ISR, status);
  289. }
  291. /*
  292.  * We have a good packet(s), get it/them out of the buffers.
  293.  */
  294. static void sonic_rx(struct net_device *dev)
  295. {
  296. unsigned int base_addr = dev->base_addr;
  297. struct sonic_local *lp = (struct sonic_local *) dev->priv;
  298. sonic_rd_t *rd = &lp->rda[lp->cur_rx & SONIC_RDS_MASK];
  299. int status;
  301. while (rd->in_use == 0) {
  302. struct sk_buff *skb;
  303. int pkt_len;
  304. unsigned char *pkt_ptr;
  306. status = rd->rx_status;
  307. if (sonic_debug > 3)
  308. printk("status %x, cur_rx %d, cur_rra %xn",
  309.        status, lp->cur_rx, lp->cur_rra);
  310. if (status & SONIC_RCR_PRX) {
  311. pkt_len = rd->rx_pktlen;
  312. pkt_ptr =
  313.     (char *)
  314.     sonic_chiptomem((rd->rx_pktptr_h << 16) +
  315.     rd->rx_pktptr_l);
  317. if (sonic_debug > 3)
  318. printk
  319.     ("pktptr %p (rba %p) h:%x l:%x, bsize h:%x l:%xn",
  320.      pkt_ptr, lp->rba, rd->rx_pktptr_h,
  321.      rd->rx_pktptr_l,
  322.      SONIC_READ(SONIC_RBWC1),
  323.      SONIC_READ(SONIC_RBWC0));
  325. /* Malloc up new buffer. */
  326. skb = dev_alloc_skb(pkt_len + 2);
  327. if (skb == NULL) {
  328. printk
  329.     ("%s: Memory squeeze, dropping packet.n",
  330.      dev->name);
  331. lp->stats.rx_dropped++;
  332. break;
  333. }
  334. skb->dev = dev;
  335. skb_reserve(skb, 2); /* 16 byte align */
  336. skb_put(skb, pkt_len); /* Make room */
  337. eth_copy_and_sum(skb, pkt_ptr, pkt_len, 0);
  338. skb->protocol = eth_type_trans(skb, dev);
  339. netif_rx(skb); /* pass the packet to upper layers */
  340. dev->last_rx = jiffies;
  341. lp->stats.rx_packets++;
  342. lp->stats.rx_bytes += pkt_len;
  344. } else {
  345. /* This should only happen, if we enable accepting broken packets. */
  346. lp->stats.rx_errors++;
  347. if (status & SONIC_RCR_FAER)
  348. lp->stats.rx_frame_errors++;
  349. if (status & SONIC_RCR_CRCR)
  350. lp->stats.rx_crc_errors++;
  351. }
  353. rd->in_use = 1;
  354. rd = &lp->rda[(++lp->cur_rx) & SONIC_RDS_MASK];
  355. /* now give back the buffer to the receive buffer area */
  356. if (status & SONIC_RCR_LPKT) {
  357. /*
  358.  * this was the last packet out of the current receice buffer
  359.  * give the buffer back to the SONIC
  360.  */
  361. lp->cur_rra += sizeof(sonic_rr_t);
  362. if (lp->cur_rra >
  363.     (lp->rra_laddr +
  364.      (SONIC_NUM_RRS -
  365.       1) * sizeof(sonic_rr_t))) lp->cur_rra =
  366.     lp->rra_laddr;
  367. SONIC_WRITE(SONIC_RWP, lp->cur_rra & 0xffff);
  368. } else
  369. printk
  370.     ("%s: rx desc without RCR_LPKT. Shouldn't happen !?n",
  371.      dev->name);
  372. }
  373. /*
  374.  * If any worth-while packets have been received, dev_rint()
  375.  * has done a mark_bh(NET_BH) for us and will work on them
  376.  * when we get to the bottom-half routine.
  377.  */
  378. }
  381. /*
  382.  * Get the current statistics.
  383.  * This may be called with the device open or closed.
  384.  */
  385. static struct net_device_stats *sonic_get_stats(struct net_device *dev)
  386. {
  387. struct sonic_local *lp = (struct sonic_local *) dev->priv;
  388. unsigned int base_addr = dev->base_addr;
  390. /* read the tally counter from the SONIC and reset them */
  391. lp->stats.rx_crc_errors += SONIC_READ(SONIC_CRCT);
  392. SONIC_WRITE(SONIC_CRCT, 0xffff);
  393. lp->stats.rx_frame_errors += SONIC_READ(SONIC_FAET);
  394. SONIC_WRITE(SONIC_FAET, 0xffff);
  395. lp->stats.rx_missed_errors += SONIC_READ(SONIC_MPT);
  396. SONIC_WRITE(SONIC_MPT, 0xffff);
  398. return &lp->stats;
  399. }
  402. /*
  403.  * Set or clear the multicast filter for this adaptor.
  404.  */
  405. static void sonic_multicast_list(struct net_device *dev)
  406. {
  407. struct sonic_local *lp = (struct sonic_local *) dev->priv;
  408. unsigned int base_addr = dev->base_addr;
  409. unsigned int rcr;
  410. struct dev_mc_list *dmi = dev->mc_list;
  411. unsigned char *addr;
  412. int i;
  414. rcr = SONIC_READ(SONIC_RCR) & ~(SONIC_RCR_PRO | SONIC_RCR_AMC);
  415. rcr |= SONIC_RCR_BRD; /* accept broadcast packets */
  417. if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
  418. rcr |= SONIC_RCR_PRO;
  419. } else {
  420. if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 15)) {
  421. rcr |= SONIC_RCR_AMC;
  422. } else {
  423. if (sonic_debug > 2)
  424. printk
  425.     ("sonic_multicast_list: mc_count %dn",
  426.      dev->mc_count);
  427. lp->cda.cam_enable = 1; /* always enable our own address */
  428. for (i = 1; i <= dev->mc_count; i++) {
  429. addr = dmi->dmi_addr;
  430. dmi = dmi->next;
  431. lp->cda.cam_desc[i].cam_cap0 =
  432.     addr[1] << 8 | addr[0];
  433. lp->cda.cam_desc[i].cam_cap1 =
  434.     addr[3] << 8 | addr[2];
  435. lp->cda.cam_desc[i].cam_cap2 =
  436.     addr[5] << 8 | addr[4];
  437. lp->cda.cam_enable |= (1 << i);
  438. }
  439. SONIC_WRITE(SONIC_CDC, 16);
  440. /* issue Load CAM command */
  441. SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
  442. SONIC_WRITE(SONIC_CMD, SONIC_CR_LCAM);
  443. }
  444. }
  446. if (sonic_debug > 2)
  447. printk("sonic_multicast_list: setting RCR=%xn", rcr);
  449. SONIC_WRITE(SONIC_RCR, rcr);
  450. }
  453. /*
  454.  * Initialize the SONIC ethernet controller.
  455.  */
  456. static int sonic_init(struct net_device *dev)
  457. {
  458. unsigned int base_addr = dev->base_addr;
  459. unsigned int cmd;
  460. struct sonic_local *lp = (struct sonic_local *) dev->priv;
  461. unsigned int rra_start;
  462. unsigned int rra_end;
  463. int i;
  465. /*
  466.  * put the Sonic into software-reset mode and
  467.  * disable all interrupts
  468.  */
  469. SONIC_WRITE(SONIC_ISR, 0x7fff);
  470. SONIC_WRITE(SONIC_IMR, 0);
  471. SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
  473. /*
  474.  * clear software reset flag, disable receiver, clear and
  475.  * enable interrupts, then completely initialize the SONIC
  476.  */
  477. SONIC_WRITE(SONIC_CMD, 0);
  478. SONIC_WRITE(SONIC_CMD, SONIC_CR_RXDIS);
  480. /*
  481.  * initialize the receive resource area
  482.  */
  483. if (sonic_debug > 2)
  484. printk("sonic_init: initialize receive resource arean");
  486. rra_start = lp->rra_laddr & 0xffff;
  487. rra_end =
  488.     (rra_start + (SONIC_NUM_RRS * sizeof(sonic_rr_t))) & 0xffff;
  490. for (i = 0; i < SONIC_NUM_RRS; i++) {
  491. lp->rra[i].rx_bufadr_l =
  492.     (lp->rba_laddr + i * SONIC_RBSIZE) & 0xffff;
  493. lp->rra[i].rx_bufadr_h =
  494.     (lp->rba_laddr + i * SONIC_RBSIZE) >> 16;
  495. lp->rra[i].rx_bufsize_l = SONIC_RBSIZE >> 1;
  496. lp->rra[i].rx_bufsize_h = 0;
  497. }
  499. /* initialize all RRA registers */
  500. SONIC_WRITE(SONIC_RSA, rra_start);
  501. SONIC_WRITE(SONIC_REA, rra_end);
  502. SONIC_WRITE(SONIC_RRP, rra_start);
  503. SONIC_WRITE(SONIC_RWP, rra_end);
  504. SONIC_WRITE(SONIC_URRA, lp->rra_laddr >> 16);
  505. SONIC_WRITE(SONIC_EOBC, (SONIC_RBSIZE - 2) >> 1);
  507. lp->cur_rra =
  508.     lp->rra_laddr + (SONIC_NUM_RRS - 1) * sizeof(sonic_rr_t);
  510. /* load the resource pointers */
  511. if (sonic_debug > 3)
  512. printk("sonic_init: issueing RRRA commandn");
  514. SONIC_WRITE(SONIC_CMD, SONIC_CR_RRRA);
  515. i = 0;
  516. while (i++ < 100) {
  517. if (SONIC_READ(SONIC_CMD) & SONIC_CR_RRRA)
  518. break;
  519. }
  521. if (sonic_debug > 2)
  522. printk("sonic_init: status=%xn", SONIC_READ(SONIC_CMD));
  524. /*
  525.  * Initialize the receive descriptors so that they
  526.  * become a circular linked list, ie. let the last
  527.  * descriptor point to the first again.
  528.  */
  529. if (sonic_debug > 2)
  530. printk("sonic_init: initialize receive descriptorsn");
  531. for (i = 0; i < SONIC_NUM_RDS; i++) {
  532. lp->rda[i].rx_status = 0;
  533. lp->rda[i].rx_pktlen = 0;
  534. lp->rda[i].rx_pktptr_l = 0;
  535. lp->rda[i].rx_pktptr_h = 0;
  536. lp->rda[i].rx_seqno = 0;
  537. lp->rda[i].in_use = 1;
  538. lp->rda[i].link =
  539.     lp->rda_laddr + (i + 1) * sizeof(sonic_rd_t);
  540. }
  541. /* fix last descriptor */
  542. lp->rda[SONIC_NUM_RDS - 1].link = lp->rda_laddr;
  543. lp->cur_rx = 0;
  544. SONIC_WRITE(SONIC_URDA, lp->rda_laddr >> 16);
  545. SONIC_WRITE(SONIC_CRDA, lp->rda_laddr & 0xffff);
  547. /* 
  548.  * initialize transmit descriptors
  549.  */
  550. if (sonic_debug > 2)
  551. printk("sonic_init: initialize transmit descriptorsn");
  552. for (i = 0; i < SONIC_NUM_TDS; i++) {
  553. lp->tda[i].tx_status = 0;
  554. lp->tda[i].tx_config = 0;
  555. lp->tda[i].tx_pktsize = 0;
  556. lp->tda[i].tx_frag_count = 0;
  557. lp->tda[i].link =
  558.     (lp->tda_laddr +
  559.      (i + 1) * sizeof(sonic_td_t)) | SONIC_END_OF_LINKS;
  560. }
  561. lp->tda[SONIC_NUM_TDS - 1].link =
  562.     (lp->tda_laddr & 0xffff) | SONIC_END_OF_LINKS;
  564. SONIC_WRITE(SONIC_UTDA, lp->tda_laddr >> 16);
  565. SONIC_WRITE(SONIC_CTDA, lp->tda_laddr & 0xffff);
  566. lp->cur_tx = lp->dirty_tx = 0;
  568. /*
  569.  * put our own address to CAM desc[0]
  570.  */
  571. lp->cda.cam_desc[0].cam_cap0 =
  572.     dev->dev_addr[1] << 8 | dev->dev_addr[0];
  573. lp->cda.cam_desc[0].cam_cap1 =
  574.     dev->dev_addr[3] << 8 | dev->dev_addr[2];
  575. lp->cda.cam_desc[0].cam_cap2 =
  576.     dev->dev_addr[5] << 8 | dev->dev_addr[4];
  577. lp->cda.cam_enable = 1;
  579. for (i = 0; i < 16; i++)
  580. lp->cda.cam_desc[i].cam_entry_pointer = i;
  582. /*
  583.  * initialize CAM registers
  584.  */
  585. SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
  586. SONIC_WRITE(SONIC_CDC, 16);
  588. /*
  589.  * load the CAM
  590.  */
  591. SONIC_WRITE(SONIC_CMD, SONIC_CR_LCAM);
  593. i = 0;
  594. while (i++ < 100) {
  595. if (SONIC_READ(SONIC_ISR) & SONIC_INT_LCD)
  596. break;
  597. }
  598. if (sonic_debug > 2) {
  599. printk("sonic_init: CMD=%x, ISR=%xn",
  600.        SONIC_READ(SONIC_CMD), SONIC_READ(SONIC_ISR));
  601. }
  603. /*
  604.  * enable receiver, disable loopback
  605.  * and enable all interrupts
  606.  */
  607. SONIC_WRITE(SONIC_CMD, SONIC_CR_RXEN | SONIC_CR_STP);
  608. SONIC_WRITE(SONIC_RCR, SONIC_RCR_DEFAULT);
  609. SONIC_WRITE(SONIC_TCR, SONIC_TCR_DEFAULT);
  610. SONIC_WRITE(SONIC_ISR, 0x7fff);
  611. SONIC_WRITE(SONIC_IMR, SONIC_IMR_DEFAULT);
  613. cmd = SONIC_READ(SONIC_CMD);
  614. if ((cmd & SONIC_CR_RXEN) == 0 || (cmd & SONIC_CR_STP) == 0)
  615. printk("sonic_init: failed, status=%xn", cmd);
  617. if (sonic_debug > 2)
  618. printk("sonic_init: new status=%xn",
  619.        SONIC_READ(SONIC_CMD));
  621. return 0;
  622. }
  624. MODULE_LICENSE("GPL");