![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i825x6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / ic|
Return to i825x6.c CVS log | Up to [The Machine Emulator] / tme / ic |
1.1 root 1: /* $Id: i825x6.c,v 1.5 2005/05/11 00:12:24 fredette Exp $ */
2:
3: /* ic/i825x6.c - implementation of the Intel 825x6 emulation: */
4:
5: /*
6: * Copyright (c) 2004 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: i825x6.c,v 1.5 2005/05/11 00:12:24 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/generic/bus-device.h>
41: #include <tme/generic/ethernet.h>
42: #undef TME_I825X6_VERSION
43: #define TME_I825X6_VERSION TME_X_VERSION(0, 0)
44: #include <tme/ic/i825x6.h>
45: #include "i825x6reg.h"
46:
47: /* macros: */
48:
49: /* these get and put values of different sizes. the values *must* be aligned: */
50: #define TME_I825X6_GET16(bytes) tme_letoh_u16(*((const tme_uint16_t *) (bytes)))
51: #define TME_I825X6_PUT16(bytes, val) (*((tme_uint16_t *) (bytes)) = tme_htole_u16(val))
52: #define TME_I82586_GET24(bytes) (tme_letoh_u32(*((const tme_uint32_t *) (bytes))) & 0xffffff)
53:
54: /* these read and write regions using DMA: */
55: #define TME_I825X6_READ(address, v) \
56: do { \
57: rc = tme_bus_device_dma_read_16(&i825x6->tme_i825x6_device, \
58: (address), \
59: sizeof(v), \
60: (tme_uint8_t *) &(v), \
61: TME_I825X6_LOCKS_DEFAULT); \
62: assert (rc == TME_OK); \
63: } while (/* CONSTCOND */ 0)
64: #define TME_I825X6_WRITE(address, v) \
65: do { \
66: rc = tme_bus_device_dma_write_16(&i825x6->tme_i825x6_device, \
67: (address), \
68: sizeof(v), \
69: (const tme_uint8_t *) &(v), \
70: TME_I825X6_LOCKS_DEFAULT); \
71: assert (rc == TME_OK); \
72: } while (/* CONSTCOND */ 0)
73:
74: /* these read and write values of different sizes using DMA: */
75: #define TME_I825X6_READ16(address, v) \
76: do { \
77: TME_I825X6_READ(address, value16); \
78: v = TME_I825X6_GET16(&value16); \
79: } while (/* CONSTCOND */ 0)
80: #define TME_I82586_READ24(address, v) \
81: do { \
82: TME_I825X6_READ(address, value32); \
83: v = TME_I82586_GET24(&value32); \
84: } while (/* CONSTCOND */ 0)
85: #define TME_I825X6_WRITE16(address, v) \
86: do { \
87: TME_I825X6_PUT16(&value16, v); \
88: TME_I825X6_WRITE(address, value16); \
89: } while (/* CONSTCOND */ 0)
90:
91: /* the "reset" stat_cus_rus_t value: */
92: #define TME_I825X6_CA_RESET (0xffff)
93:
94: /* the address of the idle "Command Block": */
95: #define TME_I825X6_CB_ADDRESS_IDLE (0xffffffff)
96:
97: /* an undefined Receive Unit address: */
98: #define TME_I825X6_RU_ADDRESS_UNDEF (0xffffffff)
99:
100: /* an undefined Receive Unit offset: */
101: #define TME_I825X6_RU_OFFSET_UNDEF (0xffff)
102:
103: /* the default locks: */
104: #define TME_I825X6_LOCKS_DEFAULT (0)
105:
106: /* the size of the TLB entry hash: */
107: #define TME_I825X6_TLB_HASH_SIZE (512)
108:
109: /* the callout flags: */
110: #define TME_I825X6_CALLOUTS_CHECK (0)
111: #define TME_I825X6_CALLOUTS_RUNNING TME_BIT(0)
112: #define TME_I825X6_CALLOUTS_MASK (-2)
113: #define TME_I825X6_CALLOUT_CTRL TME_BIT(1)
114: #define TME_I825X6_CALLOUT_CONFIG TME_BIT(2)
115: #define TME_I825X6_CALLOUT_READ TME_BIT(3)
116: #define TME_I825X6_CALLOUT_INT TME_BIT(4)
117: #define TME_I825X6_CALLOUT_CA TME_BIT(5)
118: #define TME_I825X6_CALLOUT_CU TME_BIT(6)
119:
120: /* structures: */
121:
122: /* an rx buffer: */
123: struct tme_i825x6_rx_buffer {
124:
125: /* the generic ethernet frame chunk. this must be first, since we
126: abuse its tme_ethernet_frame_chunk_next for our own next pointer: */
127: struct tme_ethernet_frame_chunk tme_i825x6_rx_buffer_frame_chunk;
128: #define TME_I825X6_RX_BUFFER_NEXT(rx_buffer) \
129: (*((struct tme_i825x6_rx_buffer **) &(rx_buffer)->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_next))
130:
131: /* when this is TME_I825X6_RU_ADDRESS_UNDEF, this rx buffer was made
132: from a fast-write TLB entry, and the generic ethernet frame chunk
133: points directly into the fast-write memory. otherwise, the
134: generic ethernet frame chunk points to a private intermediate
135: buffer, and this is the bus address to DMA the buffer back to: */
136: tme_uint32_t tme_i825x6_rx_buffer_rb_address;
137:
138: /* when this is not TME_I825X6_RU_ADDRESS_UNDEF, this rx buffer
139: finishes filling the buffer attached to the Receive Buffer
140: Descriptor at this address, and signals the receiver to update
141: that descriptor's Size field: */
142: tme_uint32_t tme_i825x6_rx_buffer_rbd_address;
143: };
144:
145: /* the chip: */
146: struct tme_i825x6 {
147:
148: /* our simple bus device header: */
149: struct tme_bus_device tme_i825x6_device;
150: #define tme_i825x6_element tme_i825x6_device.tme_bus_device_element
151:
152: /* the Ethernet connection: */
153: struct tme_ethernet_connection *tme_i825x6_eth_connection;
154:
155: /* the mutex protecting the chip: */
156: tme_mutex_t tme_i825x6_mutex;
157:
158: /* the callout flags: */
159: int tme_i825x6_callout_flags;
160:
161: /* our DMA TLB hash: */
162: TME_ATOMIC(struct tme_bus_tlb *, tme_i825x6_tlb_hash);
163:
164: /* the i825x6 bus signals: */
165: struct tme_bus_signals tme_i825x6_bus_signals;
166:
167: /* the rx buffer free list: */
168: struct tme_i825x6_rx_buffer *tme_i825x6_rx_buffer_free_list;
169:
170: /* this is nonzero if the next CA follows RESET: */
171: int tme_i825x6_ca_follows_reset;
172:
173: /* the Ethernet addresses. there are always at least two addresses
174: in this array - the broadcast address and the Individual Address,
175: in that order: */
176: unsigned int tme_i825x6_address_count;
177: tme_uint8_t *tme_i825x6_addresses;
178:
179: /* the i82586 AL-LOC value: */
180: int tme_i825x6_al_loc;
181:
182: /* the i82586 PRM value: */
183: int tme_i825x6_prm;
184:
185: /* the i82586 and 32-bit segmented i82596 SCB base: */
186: tme_uint32_t tme_i825x6_scb_base;
187:
188: /* the SCB address: */
189: tme_uint32_t tme_i825x6_scb_address;
190:
191: /* the SCB status word: */
192: tme_uint16_t tme_i825x6_stat_cus_rus_t;
193:
194: /* the SCB Command Unit Command: */
195: tme_uint16_t tme_i825x6_cuc;
196:
197: /* the CB address: */
198: tme_uint32_t tme_i825x6_cb_address;
199:
200: /* the CB status word: */
201: tme_uint16_t tme_i825x6_c_b_ok_a;
202:
203: /* the CB command word: */
204: tme_uint16_t tme_i825x6_el_s_i_cmd;
205:
206: /* the next CB address: */
207: tme_uint32_t tme_i825x6_cb_address_next;
208:
209: /* the RFD address: */
210: tme_uint32_t tme_i825x6_rfd_address;
211:
212: /* the Free Buffer List: */
213: struct tme_i825x6_rx_buffer *tme_i825x6_fbl;
214:
215: /* the size of all buffers on the Free Buffer List: */
216: tme_uint32_t tme_i825x6_fbl_size;
217:
218: /* the address of the offset of the next free RBD: */
219: tme_uint32_t tme_i825x6_rbd_offset_address;
220: };
221:
222: /* prototypes: */
223: static void _tme_i825x6_abort_ru _TME_P((struct tme_i825x6 *));
224:
225: /* globals: */
226: static const struct tme_bus_signals _tme_i825x6_bus_signals = TME_BUS_SIGNALS_I825X6;
227:
228: /* this resets the i825x6: */
229: static void
230: _tme_i825x6_reset(struct tme_i825x6 *i825x6)
231: {
232:
233: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
234: 100, TME_OK,
235: (&i825x6->tme_i825x6_element->tme_element_log_handle,
236: "reset"));
237:
238: /* clear all pending callouts: */
239: i825x6->tme_i825x6_callout_flags &= TME_I825X6_CALLOUTS_MASK;
240:
241: /* abort the Receive Unit: */
242: _tme_i825x6_abort_ru(i825x6);
243:
244: /* the Receive Unit is now Idle: */
245: i825x6->tme_i825x6_stat_cus_rus_t
246: = ((i825x6->tme_i825x6_stat_cus_rus_t
247: & ~TME_I82586_SCB_RUS_MASK)
248: | TME_I825X6_SCB_RUS_IDLE);
249:
250: /* we have no packet to transmit: */
251: i825x6->tme_i825x6_el_s_i_cmd = TME_I825X6_CB_CMD_NOP;
252:
253: /* if the interrupt line is currently asserted, negate it: */
254: if (i825x6->tme_i825x6_stat_cus_rus_t
255: & TME_I825X6_SCB_STAT_MASK) {
256: i825x6->tme_i825x6_stat_cus_rus_t &= ~TME_I825X6_SCB_STAT_MASK;
257: i825x6->tme_i825x6_callout_flags |= TME_I825X6_CALLOUT_INT;
258: }
259:
260: /* initialize the address list to match two addresses - the
261: broadcast address, and the Individual Address (which is
262: initially the same as the broadcast address): */
263: i825x6->tme_i825x6_address_count = 2;
264: memcpy (i825x6->tme_i825x6_addresses,
265: &tme_ethernet_addr_broadcast[0],
266: TME_ETHERNET_ADDR_SIZE);
267: memcpy (i825x6->tme_i825x6_addresses + TME_ETHERNET_ADDR_SIZE,
268: &tme_ethernet_addr_broadcast[0],
269: TME_ETHERNET_ADDR_SIZE);
270:
271: /* the next CA follows RESET: */
272: i825x6->tme_i825x6_ca_follows_reset = TRUE;
273: }
274:
275: /* this hashes an address into a TLB entry: */
276: static struct tme_bus_tlb *
277: _tme_i825x6_tlb_hash(void *_i825x6,
278: tme_bus_addr_t linear_address,
279: unsigned int cycles)
280: {
281: struct tme_i825x6 *i825x6;
282:
283: /* recover our data structure: */
284: i825x6 = (struct tme_i825x6 *) _i825x6;
285:
286: /* return the TLB entry: */
287: return (TME_ATOMIC_READ(struct tme_bus_tlb *, i825x6->tme_i825x6_tlb_hash)
288: + ((linear_address >> 10) & (TME_I825X6_TLB_HASH_SIZE - 1)));
289: }
290:
291: /* this locks the mutex: */
292: static void
293: _tme_i825x6_lock(void *_i825x6,
294: unsigned int locks)
295: {
296: struct tme_i825x6 *i825x6;
297:
298: /* recover our data structure: */
299: i825x6 = (struct tme_i825x6 *) _i825x6;
300:
301: /* lock the mutex: */
302: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
303: }
304:
305: /* this unlocks the mutex: */
306: static void
307: _tme_i825x6_unlock(void *_i825x6,
308: unsigned int locks)
309: {
310: struct tme_i825x6 *i825x6;
311:
312: /* recover our data structure: */
313: i825x6 = (struct tme_i825x6 *) _i825x6;
314:
315: /* unlock the mutex: */
316: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
317: }
318:
319: /* this frees an rx buffer: */
320: static struct tme_i825x6_rx_buffer *
321: _tme_i825x6_rx_buffer_free(struct tme_i825x6 *i825x6,
322: struct tme_i825x6_rx_buffer *rx_buffer)
323: {
324: struct tme_i825x6_rx_buffer *rx_buffer_next;
325:
326: /* get the next rx buffer: */
327: rx_buffer_next = TME_I825X6_RX_BUFFER_NEXT(rx_buffer);
328:
329: /* put this rx buffer on the free list: */
330: TME_I825X6_RX_BUFFER_NEXT(rx_buffer) = i825x6->tme_i825x6_rx_buffer_free_list;
331: i825x6->tme_i825x6_rx_buffer_free_list = rx_buffer;
332:
333: /* return the next rx buffer: */
334: return (rx_buffer_next);
335: }
336:
337: /* this allocates a rx buffer: */
338: static struct tme_i825x6_rx_buffer *
339: _tme_i825x6_rx_buffer_new(struct tme_i825x6 *i825x6,
340: struct tme_i825x6_rx_buffer ***__prev)
341: {
342: struct tme_i825x6_rx_buffer *rx_buffer, **_prev;
343:
344: /* if the free list is not empty: */
345: rx_buffer = i825x6->tme_i825x6_rx_buffer_free_list;
346: if (rx_buffer != NULL) {
347:
348: /* remove this rx buffer from the free list: */
349: i825x6->tme_i825x6_rx_buffer_free_list = TME_I825X6_RX_BUFFER_NEXT(rx_buffer);
350: }
351:
352: /* otherwise, the free list is empty: */
353: else {
354:
355: /* allocate a new rx buffer: */
356: rx_buffer = tme_new(struct tme_i825x6_rx_buffer, 1);
357:
358: /* treat this as an old fast-write TLB entry: */
359: rx_buffer->tme_i825x6_rx_buffer_rb_address = TME_I825X6_RU_ADDRESS_UNDEF;
360: }
361:
362: /* add this new rx buffer to the list: */
363: _prev = *__prev;
364: *_prev = rx_buffer;
365: _prev = &TME_I825X6_RX_BUFFER_NEXT(rx_buffer);
366: *__prev = _prev;
367:
368: /* return the new buffer: */
369: return (rx_buffer);
370: }
371:
372: /* given a bus address and a size, this adds rx buffers to a list: */
373: static struct tme_i825x6_rx_buffer *
374: _tme_i825x6_rx_buffers_add(struct tme_i825x6 *i825x6,
375: tme_uint32_t address_init,
376: tme_uint32_t size,
377: struct tme_i825x6_rx_buffer ***__prev)
378: {
379: struct tme_i825x6_rx_buffer *rx_buffer, **_prev;
380: struct tme_bus_tlb *tlb, tlb_local;
381: struct tme_bus_connection *conn_bus;
382: tme_bus_addr_t count_minus_one, count;
383: tme_bus_addr_t tlb_addr_last;
384: int err;
385:
386: /* recover the rx buffers list: */
387: _prev = *__prev;
388:
389: /* there isn't a last rx buffer yet: */
390: rx_buffer = NULL;
391:
392: /* loop while we have more addresses to cover: */
393: for (; size > 0; ) {
394:
395: /* hash this address into a TLB entry: */
396: tlb = _tme_i825x6_tlb_hash(i825x6,
397: address_init,
398: TME_BUS_CYCLE_WRITE);
399:
400: /* if this TLB entry doesn't cover this address, or if it doesn't
401: allow writing, reload it: */
402: tlb_addr_last = TME_ATOMIC_READ(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last);
403: if (address_init < TME_ATOMIC_READ(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first)
404: || address_init > tlb_addr_last
405: || (tlb->tme_bus_tlb_emulator_off_write == TME_EMULATOR_OFF_UNDEF
406: && !(tlb->tme_bus_tlb_cycles_ok & TME_BUS_CYCLE_WRITE))) {
407:
408: /* reserve this TLB entry: */
409: tme_bus_tlb_reserve(tlb, &tlb_local);
410: tlb = &tlb_local;
411:
412: /* get our bus connection: */
413: conn_bus = TME_ATOMIC_READ(struct tme_bus_connection *,
414: i825x6->tme_i825x6_device.tme_bus_device_connection);
415:
416: /* unlock the mutex: */
417: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
418:
419: /* reload the TLB entry: */
420: err = (*conn_bus->tme_bus_tlb_fill)
421: (conn_bus,
422: tlb,
423: address_init,
424: TME_BUS_CYCLE_WRITE);
425:
426: /* lock the mutex: */
427: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
428:
429: /* XXX we could create a poison frame chunk instead of
430: aborting: */
431: if (err != TME_OK) {
432: abort();
433: }
434:
435: /* the TLB entry must cover this address and allow writing: */
436: tlb_addr_last = TME_ATOMIC_READ(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last);
437: assert (address_init >= TME_ATOMIC_READ(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first)
438: && address_init <= tlb_addr_last
439: && (tlb->tme_bus_tlb_emulator_off_write != TME_EMULATOR_OFF_UNDEF
440: || (tlb->tme_bus_tlb_cycles_ok & TME_BUS_CYCLE_WRITE)));
441:
442: /* store the TLB entry: */
443: tme_bus_tlb_back(tlb);
444: }
445:
446: /* see how many addresses we can cover with this TLB entry,
447: starting at this address: */
448: count_minus_one = (tlb_addr_last - address_init);
449: count_minus_one = TME_MIN(count_minus_one,
450: (size - 1));
451: count = count_minus_one + 1;
452: assert (count != 0);
453:
454: /* allocate another rx buffer: */
455: rx_buffer = _tme_i825x6_rx_buffer_new(i825x6, &_prev);
456:
457: /* if this TLB entry allows fast writing: */
458: if (tlb->tme_bus_tlb_emulator_off_write != TME_EMULATOR_OFF_UNDEF) {
459:
460: /* if this rx buffer was previously a slow rx buffer, free its
461: chunk buffer: */
462: if (rx_buffer->tme_i825x6_rx_buffer_rb_address != TME_I825X6_RU_ADDRESS_UNDEF) {
463: tme_free(rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes);
464: }
465:
466: /* this is a fast rx buffer: */
467: rx_buffer->tme_i825x6_rx_buffer_rb_address = TME_I825X6_RU_ADDRESS_UNDEF;
468: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes
469: = tlb->tme_bus_tlb_emulator_off_write + address_init;
470: }
471:
472: /* otherwise, this TLB entry does not allow fast writing: */
473: else {
474:
475: /* if this rx buffer was previously a fast rx buffer,
476: allocate a new chunk buffer: */
477: if (rx_buffer->tme_i825x6_rx_buffer_rb_address == TME_I825X6_RU_ADDRESS_UNDEF) {
478: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes
479: = tme_new(tme_uint8_t,
480: count);
481: }
482:
483: /* otherwise, if this rx buffer was previously a slow receive
484: buffer, with a chunk buffer smaller than what we need,
485: reallocate the chunk buffer: */
486: else if (rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes_count
487: < count) {
488: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes
489: = tme_renew(tme_uint8_t,
490: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes,
491: count);
492: }
493:
494: /* this is a slow frame chunk: */
495: rx_buffer->tme_i825x6_rx_buffer_rb_address = address_init;
496: }
497:
498: /* finish this rx buffer: */
499: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes_count = count;
500: rx_buffer->tme_i825x6_rx_buffer_rbd_address = TME_I825X6_RU_ADDRESS_UNDEF;
501:
502: /* update the address and size: */
503: address_init += count;
504: size -= count;
505: }
506:
507: /* update the rx buffers list end: */
508: *__prev = _prev;
509:
510: /* return the last rx buffer: */
511: return (rx_buffer);
512: }
513:
514: /* this refills the Free Buffer List: */
515: static tme_uint16_t
516: _tme_i825x6_fbl_refill(struct tme_i825x6 *i825x6, int from_rfd)
517: {
518: struct tme_i825x6_rx_buffer *rx_buffer, **_prev;
519: tme_uint32_t fbl_size;
520: tme_uint32_t rbd_offset_address, rbd_address, rb_address;
521: tme_uint16_t rbd_offset, rbd_offset_first;
522: tme_uint16_t el_p_size;
523: tme_uint16_t size;
524: tme_uint32_t value32;
525: tme_uint16_t value16;
526: int rc;
527:
528: /* assume that there are no free Receive Buffer Descriptors: */
529: rbd_offset_first = TME_I825X6_RU_OFFSET_UNDEF;
530:
531: /* find the end of the Free Buffer List: */
532: for (_prev = &i825x6->tme_i825x6_fbl;
533: (rx_buffer = *_prev) != NULL;
534: _prev = &TME_I825X6_RX_BUFFER_NEXT(rx_buffer)) {
535:
536: /* if we don't have the first free Receive Buffer Descriptor yet,
537: and this is the last rx buffer for a Receive Buffer, its
538: Receive Buffer Descriptor is the first free one: */
539: rbd_address = rx_buffer->tme_i825x6_rx_buffer_rbd_address;
540: if (rbd_offset_first == TME_I825X6_RU_OFFSET_UNDEF
541: && rbd_address != TME_I825X6_RU_ADDRESS_UNDEF) {
542: rbd_offset_first = rbd_address - i825x6->tme_i825x6_scb_base;
543: }
544: }
545:
546: /* get the address of the next RBD offset: */
547: rbd_offset_address = i825x6->tme_i825x6_rbd_offset_address;
548:
549: /* stop now if the address of the next RBD offset is undefined: */
550: if (rbd_offset_address == TME_I825X6_RU_ADDRESS_UNDEF) {
551: return (rbd_offset_first);
552: }
553:
554: /* get the current size of the Free Buffer List: */
555: fbl_size = i825x6->tme_i825x6_fbl_size;
556:
557: /* turn Receive Buffers into rx buffers on the Free Buffer List,
558: until the Free Buffer List has a maximum-sized Ethernet frame's
559: worth of buffers: */
560: for (; fbl_size < TME_ETHERNET_FRAME_MAX; ) {
561:
562: /* read in the Receive Buffer Descriptor offset: */
563: TME_I825X6_READ16(rbd_offset_address,
564: rbd_offset);
565:
566: /* if this Receive Buffer Descriptor offset is in an RFD, stop if
567: the offset is all-bits-one, indicating no RBDs: */
568: if (from_rfd
569: && rbd_offset == TME_I825X6_RU_OFFSET_UNDEF) {
570: break;
571: }
572: from_rfd = FALSE;
573:
574: /* if we don't have the first free Receive Buffer Descriptor yet,
575: this is it: */
576: if (rbd_offset_first == TME_I825X6_RU_OFFSET_UNDEF) {
577: rbd_offset_first = rbd_offset;
578: }
579:
580: /* make the Receive Buffer Descriptor address: */
581: rbd_address = i825x6->tme_i825x6_scb_base + rbd_offset;
582:
583: /* read in the Receive Buffer address: */
584: TME_I82586_READ24((rbd_address
585: + TME_I82586_RBD_RB_ADDRESS),
586: rb_address);
587:
588: /* read in the EL_P_SIZE field: */
589: TME_I825X6_READ16((rbd_address
590: + TME_I82586_RBD_EL_P_SIZE),
591: el_p_size);
592:
593: /* get the size of this Receive Buffer: */
594: size = el_p_size & TME_I825X6_RBD_SIZE_MASK;
595:
596: /* if this Receive Buffer has zero size, stop now. this can
597: happen with NetBSD 1.6.x, which zeroes and reinitializes the
598: memory for the i825x6 without stopping the Receive Unit: */
599: if (size == 0) {
600:
601: /* log a complaint: */
602: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
603: 0, EBADF,
604: (&i825x6->tme_i825x6_element->tme_element_log_handle,
605: _("caught an empty Receive Buffer")));
606:
607: break;
608: }
609:
610: /* add this Receive Buffer to the rx buffers: */
611: rx_buffer = _tme_i825x6_rx_buffers_add(i825x6,
612: rb_address,
613: size,
614: &_prev);
615:
616: /* on the last rx buffer for a Receive Buffer, set the address of
617: the Receive Buffer Descriptor, so we can update its size field: */
618: rx_buffer->tme_i825x6_rx_buffer_rbd_address = rbd_address;
619:
620: /* update the amount of space on the Free Buffer list: */
621: fbl_size += size;
622:
623: /* if this is the last Receive Buffer Descriptor: */
624: if (el_p_size & TME_I825X6_RBD_EL) {
625:
626: /* the address of the next RBD offset is undefined: */
627: rbd_offset_address = TME_I825X6_RU_ADDRESS_UNDEF;
628:
629: /* stop now: */
630: break;
631: }
632:
633: /* get the address of the next RBD offset: */
634: rbd_offset_address
635: = (rbd_address
636: + TME_I82586_RBD_RBD_OFFSET);
637: }
638:
639: /* terminate the Free Buffer List: */
640: *_prev = NULL;
641:
642: /* save the current size of the Free Buffer List: */
643: i825x6->tme_i825x6_fbl_size = fbl_size;
644:
645: /* save the address of the next RBD offset: */
646: i825x6->tme_i825x6_rbd_offset_address = rbd_offset_address;
647:
648: /* return the address of the first free Receive Buffer Descriptor: */
649: return (rbd_offset_first);
650: }
651:
652: /* this aborts the Receive Unit: */
653: static void
654: _tme_i825x6_abort_ru(struct tme_i825x6 *i825x6)
655: {
656: struct tme_i825x6_rx_buffer *rx_buffer;
657:
658: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
659: 100, TME_OK,
660: (&i825x6->tme_i825x6_element->tme_element_log_handle,
661: "RU abort"));
662:
663: /* free the Free Buffer List: */
664: for (rx_buffer = i825x6->tme_i825x6_fbl;
665: rx_buffer != NULL;
666: rx_buffer = _tme_i825x6_rx_buffer_free(i825x6, rx_buffer));
667:
668: /* the Receive Unit now has no resources: */
669: i825x6->tme_i825x6_rfd_address = TME_I825X6_RU_ADDRESS_UNDEF;
670: i825x6->tme_i825x6_rbd_offset_address = TME_I825X6_RU_ADDRESS_UNDEF;
671: i825x6->tme_i825x6_fbl = NULL;
672: i825x6->tme_i825x6_fbl_size = 0;
673: }
674:
675: /* this does a DMA directly into transmit frame chunks: */
676: static int
677: _tme_i825x6_chunks_dma_tx(struct tme_i825x6 *i825x6,
678: struct tme_ethernet_frame_chunk *frame_chunks,
679: tme_uint32_t address,
680: tme_uint32_t size)
681: {
682: tme_uint32_t count;
683: int rc;
684:
685: /* while we have bytes left to DMA: */
686: for (; size > 0; ) {
687:
688: /* get the count of bytes to copy in this iteration: */
689: count = frame_chunks->tme_ethernet_frame_chunk_bytes_count;
690: if (count == 0) {
691: break;
692: }
693: count = TME_MIN(count, size);
694:
695: /* do the copy: */
696: /* XXX FIXME this assumes an i82586: */
697: rc = tme_bus_device_dma_read_16(&i825x6->tme_i825x6_device,
698: address,
699: count,
700: frame_chunks->tme_ethernet_frame_chunk_bytes,
701: TME_I825X6_LOCKS_DEFAULT);
702: if (rc != TME_OK) {
703: return (rc);
704: }
705:
706: /* update: */
707: size -= count;
708: frame_chunks->tme_ethernet_frame_chunk_bytes += count;
709: if ((frame_chunks->tme_ethernet_frame_chunk_bytes_count -= count) == 0
710: && frame_chunks->tme_ethernet_frame_chunk_next != NULL) {
711: *frame_chunks = *frame_chunks->tme_ethernet_frame_chunk_next;
712: }
713: }
714:
715: /* success: */
716: return (TME_OK);
717: }
718:
719: /* this does a memcpy directly into transmit frame chunks: */
720: static void
721: _tme_i825x6_chunks_mem_tx(struct tme_ethernet_frame_chunk *frame_chunks,
722: const tme_uint8_t *data,
723: unsigned int size)
724: {
725: unsigned int count;
726:
727: /* while we have bytes left to copy: */
728: for (; size > 0; ) {
729:
730: /* get the count of bytes to copy in this iteration: */
731: count = frame_chunks->tme_ethernet_frame_chunk_bytes_count;
732: if (count == 0) {
733: break;
734: }
735: count = TME_MIN(count, size);
736:
737: /* do the copy: */
738: memcpy(frame_chunks->tme_ethernet_frame_chunk_bytes,
739: data,
740: count);
741:
742: /* update: */
743: size -= count;
744: frame_chunks->tme_ethernet_frame_chunk_bytes += count;
745: if ((frame_chunks->tme_ethernet_frame_chunk_bytes_count -= count) == 0
746: && frame_chunks->tme_ethernet_frame_chunk_next != NULL) {
747: *frame_chunks = *frame_chunks->tme_ethernet_frame_chunk_next;
748: }
749: }
750: }
751:
752: /* this is called to handle a Channel Attention (CA) callout: */
753: static tme_uint16_t
754: _tme_i825x6_callout_ca(struct tme_i825x6 *i825x6, tme_uint16_t stat_cus_rus_t)
755: {
756: tme_uint8_t scp[TME_I825X6_SCP_SIZE];
757: tme_uint32_t iscp_address, rfd_offset;
758: tme_uint8_t iscp[TME_I825X6_ISCP_SIZE];
759: tme_uint16_t ack_cuc_r_ruc;
760: tme_uint16_t cuc;
761: tme_uint16_t value16;
762: tme_uint16_t rbd_offset_first;
763: int rc;
764:
765: /* if this CA follows RESET: */
766: if (i825x6->tme_i825x6_ca_follows_reset) {
767:
768: /* the next CA will not follow RESET: */
769: i825x6->tme_i825x6_ca_follows_reset = FALSE;
770:
771: /* read in the SCP: */
772: TME_I825X6_READ(TME_I825X6_SCP_ADDRESS, scp);
773:
774: /* check the SYSBUS byte: */
775: assert ((scp[TME_I825X6_SCP_SYSBUS]
776: & TME_I825X6_SCP_SYSBUS_MODE_MASK)
777: == TME_I825X6_SCP_SYSBUS_MODE_82586);
778:
779: /* get the ISCP address: */
780: iscp_address = TME_I82586_GET24(&scp[TME_I825X6_SCP_ISCP_ADDRESS]);
781:
782: /* read in the ISCP: */
783: TME_I825X6_READ(iscp_address, iscp);
784:
785: /* get the SCB base and SCB address: */
786: i825x6->tme_i825x6_scb_base = TME_I82586_GET24(&iscp[TME_I82586_ISCP_SCB_BASE]);
787: i825x6->tme_i825x6_scb_address
788: = (i825x6->tme_i825x6_scb_base
789: + TME_I825X6_GET16(&iscp[TME_I82586_ISCP_SCB_OFFSET]));
790:
791: /* "The 82596 clears BUSY": */
792: iscp[TME_I825X6_ISCP_BUSY] = 0;
793: TME_I825X6_WRITE((iscp_address
794: + TME_I825X6_ISCP_BUSY),
795: iscp[TME_I825X6_ISCP_BUSY]);
796:
797: /* "The 82596 ... sets CX and CNR to equal 1 in the SCB": */
798: stat_cus_rus_t
799: = (TME_I825X6_SCB_STAT_CX
800: | TME_I825X6_SCB_STAT_CNA
801: | TME_I825X6_SCB_CUS_IDLE
802: | TME_I825X6_SCB_RUS_IDLE);
803:
804: /* "The 82596 ... sends an interrupt to the CPU": */
805: i825x6->tme_i825x6_callout_flags = TME_I825X6_CALLOUTS_RUNNING | TME_I825X6_CALLOUT_INT;
806: }
807:
808: /* otherwise, this CA does not follow RESET: */
809: else {
810:
811: /* read in the SCB command word: */
812: TME_I825X6_READ16((i825x6->tme_i825x6_scb_address
813: + TME_I825X6_SCB_ACK_CUC_R_RUC),
814: ack_cuc_r_ruc);
815:
816: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
817: 100, TME_OK,
818: (&i825x6->tme_i825x6_element->tme_element_log_handle,
819: "SCB command 0x%04x",
820: ack_cuc_r_ruc));
821:
822: /* handle a Reset: */
823: if (ack_cuc_r_ruc & TME_I825X6_SCB_RESET) {
824: _tme_i825x6_reset(i825x6);
825: return (TME_I825X6_CA_RESET);
826: }
827:
828: /* clear any acknowledged Status bits: */
829: stat_cus_rus_t
830: &= ~(ack_cuc_r_ruc
831: & TME_I825X6_SCB_STAT_MASK);
832:
833: /* if the Command Unit Command isn't a NOP: */
834: cuc = (ack_cuc_r_ruc
835: & TME_I825X6_SCB_CUC_MASK);
836: if (cuc != TME_I825X6_SCB_CUC_NOP) {
837:
838: /* set this Command Unit Command: */
839: i825x6->tme_i825x6_cuc = cuc;
840:
841: /* if the Command Unit Command is an Abort, or if the Command
842: Unit isn't already Active, run the Command Unit: */
843: if ((cuc == TME_I825X6_SCB_CUC_ABORT)
844: || ((stat_cus_rus_t
845: & TME_I825X6_SCB_CUS_MASK)
846: != TME_I825X6_SCB_CUS_ACTIVE)) {
847: i825x6->tme_i825x6_callout_flags |= TME_I825X6_CALLOUT_CU;
848: }
849: }
850:
851: /* dispatch on the Receive Unit command: */
852: switch (ack_cuc_r_ruc & TME_I825X6_SCB_RUC_MASK) {
853:
854: case TME_I825X6_SCB_RUC_NOP:
855: break;
856:
857: case TME_I825X6_SCB_RUC_START:
858:
859: /* if the Receive Unit is still Ready or Suspended: */
860: switch (stat_cus_rus_t & TME_I82586_SCB_RUS_MASK) {
861: case TME_I825X6_SCB_RUS_READY:
862: case TME_I825X6_SCB_RUS_SUSPENDED:
863:
864: /* abort the Receive Unit: */
865: _tme_i825x6_abort_ru(i825x6);
866: break;
867:
868: case TME_I825X6_SCB_RUS_ERESOURCE:
869: case TME_I825X6_SCB_RUS_IDLE:
870: break;
871:
872: default:
873: abort();
874: }
875:
876: /* the Receive Unit must have no resources: */
877: assert (i825x6->tme_i825x6_rfd_address == TME_I825X6_RU_ADDRESS_UNDEF);
878: assert (i825x6->tme_i825x6_rbd_offset_address == TME_I825X6_RU_ADDRESS_UNDEF);
879: assert (i825x6->tme_i825x6_fbl == NULL && i825x6->tme_i825x6_fbl_size == 0);
880:
881: /* get the RFD offset from the SCB: */
882: TME_I825X6_READ16((i825x6->tme_i825x6_scb_address
883: + TME_I82586_SCB_RFA_OFFSET),
884: rfd_offset);
885:
886: /* if the RFD offset is defined: */
887: if (rfd_offset != TME_I825X6_RU_OFFSET_UNDEF) {
888:
889: /* set the RFD address: */
890: i825x6->tme_i825x6_rfd_address
891: = (i825x6->tme_i825x6_scb_base
892: + rfd_offset);
893:
894: /* set the RBD offset address: */
895: i825x6->tme_i825x6_rbd_offset_address
896: = (i825x6->tme_i825x6_rfd_address
897: + TME_I82586_RFD_RBD_OFFSET);
898:
899: /* refill the Free Buffer List: */
900: rbd_offset_first = _tme_i825x6_fbl_refill(i825x6, TRUE);
901:
902: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
903: 100, TME_OK,
904: (&i825x6->tme_i825x6_element->tme_element_log_handle,
905: "RU start RFD 0x%06x RBD 0x%04x",
906: i825x6->tme_i825x6_rfd_address,
907: rbd_offset_first));
908: }
909:
910: /* FALLTHROUGH: */
911: case TME_I825X6_SCB_RUC_RESUME:
912:
913: /* the Receive Unit is now Ready: */
914: stat_cus_rus_t
915: = ((stat_cus_rus_t
916: & ~TME_I82586_SCB_RUS_MASK)
917: | TME_I825X6_SCB_RUS_READY);
918: break;
919:
920: case TME_I825X6_SCB_RUC_SUSPEND:
921:
922: /* the Receive Unit is now Suspended: */
923: stat_cus_rus_t
924: = ((stat_cus_rus_t
925: & ~TME_I82586_SCB_RUS_MASK)
926: | TME_I825X6_SCB_RUS_SUSPENDED);
927: break;
928:
929: case TME_I825X6_SCB_RUC_ABORT:
930:
931: /* abort the Receive Unit: */
932: _tme_i825x6_abort_ru(i825x6);
933:
934: /* the Receive Unit is now Idle: */
935: stat_cus_rus_t
936: = ((stat_cus_rus_t
937: & ~TME_I82586_SCB_RUS_MASK)
938: | TME_I825X6_SCB_RUS_IDLE);
939: break;
940:
941: default:
942: abort();
943: }
944: }
945:
946: /* always clear the SCB command word after a CA: */
947: TME_I825X6_WRITE16((i825x6->tme_i825x6_scb_address
948: + TME_I825X6_SCB_ACK_CUC_R_RUC),
949: 0);
950:
951: /* return the current status word: */
952: return (stat_cus_rus_t);
953: }
954:
955: /* this is called to handle a Command Unit (CU) callout: */
956: static tme_uint16_t
957: _tme_i825x6_callout_cu(struct tme_i825x6 *i825x6, tme_uint16_t stat_cus_rus_t)
958: {
959: tme_uint16_t cuc;
960: tme_uint16_t el_s_i_cmd;
961: tme_uint16_t mc_count;
962: tme_uint8_t config_bytes[12];
963: unsigned int config_byte_count;
964: unsigned int callouts;
965: tme_uint16_t value16;
966: int rc;
967:
968: /* get the SCB Command Unit Command: */
969: cuc = i825x6->tme_i825x6_cuc;
970:
971: /* if the Command Unit was active, complete the command that it
972: was working on: */
973: if ((stat_cus_rus_t
974: & TME_I825X6_SCB_CUS_MASK)
975: == TME_I825X6_SCB_CUS_ACTIVE) {
976:
977: /* finish the CB status word. clear B, and set C. if the
978: command was aborted, clear OK and set A, else set OK and
979: clear A: */
980: i825x6->tme_i825x6_c_b_ok_a
981: = ((i825x6->tme_i825x6_c_b_ok_a
982: & ~TME_I825X6_FLAG_B)
983: | TME_I825X6_FLAG_C
984: | TME_I825X6_FLAG_OK
985: | TME_I825X6_CB_A);
986: i825x6->tme_i825x6_c_b_ok_a
987: ^= ((cuc
988: == TME_I825X6_SCB_CUC_ABORT)
989: ? TME_I825X6_FLAG_OK
990: : TME_I825X6_CB_A);
991:
992: /* write the CB status word: */
993: TME_I825X6_WRITE16((i825x6->tme_i825x6_cb_address
994: + TME_I825X6_CB_C_B_OK_A),
995: i825x6->tme_i825x6_c_b_ok_a);
996:
997: /* if this command had the I bit set, set CX: */
998: if (i825x6->tme_i825x6_el_s_i_cmd & TME_I825X6_CB_I) {
999: stat_cus_rus_t |= TME_I825X6_SCB_STAT_CX;
1000: }
1001:
1002: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
1003: 100, TME_OK,
1004: (&i825x6->tme_i825x6_element->tme_element_log_handle,
1005: "CU finish 0x%06x status 0x%04x",
1006: i825x6->tme_i825x6_cb_address,
1007: i825x6->tme_i825x6_c_b_ok_a));
1008: }
1009:
1010: /* dispatch on the Command Unit command: */
1011: switch (cuc) {
1012:
1013: case TME_I825X6_SCB_CUC_NOP:
1014: break;
1015:
1016: case TME_I825X6_SCB_CUC_START:
1017:
1018: /* get the CBL address: */
1019: TME_I825X6_READ16((i825x6->tme_i825x6_scb_address
1020: + TME_I82586_SCB_CBL_OFFSET),
1021: i825x6->tme_i825x6_cb_address_next);
1022: i825x6->tme_i825x6_cb_address_next += i825x6->tme_i825x6_scb_base;
1023:
1024: /* FALLTHROUGH */
1025: case TME_I825X6_SCB_CUC_RESUME:
1026:
1027: /* the Command Unit is now active: */
1028: stat_cus_rus_t
1029: = ((stat_cus_rus_t
1030: & ~TME_I825X6_SCB_CUS_MASK)
1031: | TME_I825X6_SCB_CUS_ACTIVE);
1032: break;
1033:
1034: case TME_I825X6_SCB_CUC_ABORT:
1035:
1036: /* the Command Unit is now Idle: */
1037: stat_cus_rus_t
1038: = ((stat_cus_rus_t
1039: & ~TME_I825X6_SCB_CUS_MASK)
1040: | TME_I825X6_SCB_CUS_IDLE);
1041: break;
1042:
1043: case TME_I825X6_SCB_CUC_SUSPEND:
1044:
1045: /* the Command Unit is now Suspended: */
1046: stat_cus_rus_t
1047: = ((stat_cus_rus_t
1048: & ~TME_I825X6_SCB_CUS_MASK)
1049: | TME_I825X6_SCB_CUS_SUSPENDED);
1050: break;
1051:
1052: default:
1053: abort();
1054: }
1055:
1056: /* if the Command Unit is not active, return now: */
1057: if ((stat_cus_rus_t
1058: & TME_I825X6_SCB_CUS_MASK)
1059: != TME_I825X6_SCB_CUS_ACTIVE) {
1060: return (stat_cus_rus_t);
1061: }
1062:
1063: /* advance to the next command: */
1064: i825x6->tme_i825x6_cb_address = i825x6->tme_i825x6_cb_address_next;
1065:
1066: /* if there is no next command, the Command Unit is now Idle: */
1067: if (i825x6->tme_i825x6_cb_address == TME_I825X6_CB_ADDRESS_IDLE) {
1068: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
1069: 100, TME_OK,
1070: (&i825x6->tme_i825x6_element->tme_element_log_handle,
1071: "CU idle"));
1072: stat_cus_rus_t
1073: = ((stat_cus_rus_t
1074: & ~TME_I825X6_SCB_CUS_MASK)
1075: | TME_I825X6_SCB_CUS_IDLE);
1076: return (stat_cus_rus_t);
1077: }
1078:
1079: /* start the CB status word: */
1080: i825x6->tme_i825x6_c_b_ok_a = TME_I825X6_FLAG_B;
1081: TME_I825X6_WRITE16((i825x6->tme_i825x6_cb_address
1082: + TME_I825X6_CB_C_B_OK_A),
1083: i825x6->tme_i825x6_c_b_ok_a);
1084:
1085: /* get the CB command word: */
1086: TME_I825X6_READ16((i825x6->tme_i825x6_cb_address
1087: + TME_I825X6_CB_EL_S_I_CMD),
1088: i825x6->tme_i825x6_el_s_i_cmd);
1089: el_s_i_cmd = i825x6->tme_i825x6_el_s_i_cmd;
1090:
1091: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
1092: 100, TME_OK,
1093: (&i825x6->tme_i825x6_element->tme_element_log_handle,
1094: "CU start 0x%06x el_s_i_cmd 0x%04x",
1095: i825x6->tme_i825x6_cb_address,
1096: el_s_i_cmd));
1097:
1098: /* if EL is set, there is no next Command Block, and when
1099: the Command Unit tries to execute the next command it
1100: will go Idle: */
1101: if (el_s_i_cmd & TME_I825X6_FLAG_EL) {
1102: i825x6->tme_i825x6_cb_address_next = TME_I825X6_CB_ADDRESS_IDLE;
1103: }
1104:
1105: /* otherwise, get the address of the next Command Block: */
1106: else {
1107: TME_I825X6_READ16((i825x6->tme_i825x6_cb_address
1108: + TME_I82586_CB_LINK_OFFSET),
1109: i825x6->tme_i825x6_cb_address_next);
1110: i825x6->tme_i825x6_cb_address_next += i825x6->tme_i825x6_scb_base;
1111: }
1112:
1113: /* if S is set, after the Command Unit executes this command
1114: it will Suspend, else it will stay Active: */
1115: i825x6->tme_i825x6_cuc
1116: = ((el_s_i_cmd & TME_I825X6_FLAG_S)
1117: ? TME_I825X6_SCB_CUC_SUSPEND
1118: : TME_I825X6_SCB_CUC_NOP);
1119:
1120: /* assume that this command will complete now: */
1121: callouts = TME_I825X6_CALLOUT_CU;
1122:
1123: /* dispatch on this command: */
1124: switch (el_s_i_cmd & TME_I825X6_CB_CMD_MASK) {
1125:
1126: case TME_I825X6_CB_CMD_NOP:
1127: break;
1128:
1129: case TME_I825X6_CB_CMD_SETUP_IA:
1130:
1131: /* read in the new Individual Address, into the second element of
1132: the addresses array: */
1133: rc = tme_bus_device_dma_read_16(&i825x6->tme_i825x6_device,
1134: (i825x6->tme_i825x6_cb_address
1135: + TME_I82586_CB_X),
1136: TME_ETHERNET_ADDR_SIZE,
1137: (i825x6->tme_i825x6_addresses
1138: + TME_ETHERNET_ADDR_SIZE),
1139: TME_I825X6_LOCKS_DEFAULT);
1140: assert (rc == TME_OK);
1141:
1142: /* call out an Ethernet configuration change: */
1143: callouts |= TME_I825X6_CALLOUT_CONFIG;
1144: break;
1145:
1146: case TME_I825X6_CB_CMD_CONFIGURE:
1147:
1148: /* read in bytes 0 and 1 of the configuration: */
1149: rc = tme_bus_device_dma_read_16(&i825x6->tme_i825x6_device,
1150: (i825x6->tme_i825x6_cb_address
1151: + TME_I82586_CB_X),
1152: sizeof(tme_uint16_t),
1153: config_bytes,
1154: TME_I825X6_LOCKS_DEFAULT);
1155: assert (rc == TME_OK);
1156:
1157: /* "In the 82586 mode the maximum number of configuration bytes
1158: is 12. Any number larger than 12 will be reduced to 12 and
1159: any number less than 4 will be increased to 4." */
1160: config_byte_count = (config_bytes[0] & 0x0f);
1161: if (config_byte_count < 4) {
1162: config_byte_count = 4;
1163: }
1164: else if (config_byte_count > 12) {
1165: config_byte_count = 12;
1166: }
1167:
1168: /* read in the remaining bytes of the configuration: */
1169: rc = tme_bus_device_dma_read_16(&i825x6->tme_i825x6_device,
1170: (i825x6->tme_i825x6_cb_address
1171: + TME_I82586_CB_X
1172: + sizeof(tme_uint16_t)),
1173: (config_byte_count
1174: - sizeof(tme_uint16_t)),
1175: (config_bytes
1176: + sizeof(tme_uint16_t)),
1177: TME_I825X6_LOCKS_DEFAULT);
1178: assert (rc == TME_OK);
1179:
1180: /* byte 3: */
1181: if (config_byte_count > 3) {
1182:
1183: /* AL-LOC: */
1184: i825x6->tme_i825x6_al_loc = config_bytes[3] & 0x08;
1185:
1186: /* Address Length: */
1187: if ((config_bytes[3] & 0x07) != TME_ETHERNET_ADDR_SIZE) {
1188: abort();
1189: }
1190: }
1191:
1192: /* byte 8: */
1193: if (config_byte_count > 8) {
1194:
1195: /* Promiscuous Mode: */
1196: i825x6->tme_i825x6_prm = config_bytes[8] & 0x01;
1197:
1198: /* call out an Ethernet configuration change: */
1199: callouts |= TME_I825X6_CALLOUT_CONFIG;
1200: }
1201: break;
1202:
1203: case TME_I825X6_CB_CMD_SETUP_MC:
1204:
1205: /* read in the MC COUNT byte count: */
1206: TME_I825X6_READ16((i825x6->tme_i825x6_cb_address
1207: + TME_I82586_CB_X),
1208: mc_count);
1209: mc_count -= (mc_count % TME_ETHERNET_ADDR_SIZE);
1210:
1211: /* reallocate the addresses list, which is always at least two
1212: elements long - the broadcast address and the individual
1213: address: */
1214: i825x6->tme_i825x6_address_count = (2 + (mc_count / TME_ETHERNET_ADDR_SIZE));
1215: i825x6->tme_i825x6_addresses
1216: = tme_renew(tme_uint8_t,
1217: i825x6->tme_i825x6_addresses,
1218: (i825x6->tme_i825x6_address_count
1219: * TME_ETHERNET_ADDR_SIZE));
1220:
1221: /* read in the new Multicast addresses: */
1222: rc = tme_bus_device_dma_read_16(&i825x6->tme_i825x6_device,
1223: (i825x6->tme_i825x6_cb_address
1224: + TME_I82586_CB_X
1225: + sizeof(mc_count)),
1226: mc_count,
1227: (i825x6->tme_i825x6_addresses
1228: + (2
1229: * TME_ETHERNET_ADDR_SIZE)),
1230: TME_I825X6_LOCKS_DEFAULT);
1231: assert (rc == TME_OK);
1232:
1233: /* call out an Ethernet configuration change: */
1234: callouts |= TME_I825X6_CALLOUT_CONFIG;
1235: break;
1236:
1237: case TME_I825X6_CB_CMD_TRANSMIT:
1238:
1239: /* call out only a control change; this command is not
1240: completing now: */
1241: callouts = TME_I825X6_CALLOUT_CTRL;
1242: break;
1243:
1244: case TME_I825X6_CB_CMD_TDR:
1245:
1246: /* write a successful TDR status: */
1247: TME_I825X6_WRITE16((i825x6->tme_i825x6_cb_address
1248: + TME_I82586_CB_X),
1249: TME_I82586_TDR_STATUS_OK);
1250: break;
1251:
1252: case TME_I825X6_CB_CMD_DUMP:
1253: case TME_I825X6_CB_CMD_DIAGNOSE:
1254: abort();
1255: }
1256:
1257: /* add to the callouts and return the current status: */
1258: i825x6->tme_i825x6_callout_flags |= callouts;
1259: return (stat_cus_rus_t);
1260: }
1261:
1262: /* this is called to handle a Receive Unit (RU) callout: */
1263: static tme_uint16_t
1264: _tme_i825x6_callout_ru(struct tme_i825x6 *i825x6, tme_uint16_t stat_cus_rus_t)
1265: {
1266: struct tme_ethernet_connection *conn_eth;
1267: tme_ethernet_fid_t frame_id;
1268: tme_uint16_t el_s_sf;
1269: tme_uint16_t eof_f_act_count;
1270: tme_uint16_t c_b_ok_status;
1271: struct tme_i825x6_rx_buffer *rx_buffers, *rx_buffer, **_prev;
1272: unsigned int rbd_size, rx_buffer_size;
1273: tme_uint32_t rfd_address;
1274: tme_uint16_t rbd_offset_next;
1275: tme_uint16_t discards;
1276: int resid;
1277: int rc;
1278: tme_uint16_t value16;
1279:
1280: /* start a list of rx buffers: */
1281: rx_buffers = NULL;
1282: _prev = &rx_buffers;
1283:
1284: /* start counting the number of bytes in the first Receive Buffer: */
1285: rbd_size = 0;
1286:
1287: /* assume that we have no Receive Frame Descriptor: */
1288: rfd_address = TME_I825X6_RU_ADDRESS_UNDEF;
1289: el_s_sf = 0;
1290:
1291: /* if the Receive Unit is Active and we have a Receive Frame Descriptor: */
1292: if (((stat_cus_rus_t & TME_I82586_SCB_RUS_MASK)
1293: == TME_I825X6_SCB_RUS_READY)
1294: && ((rfd_address = i825x6->tme_i825x6_rfd_address)
1295: != TME_I825X6_RU_ADDRESS_UNDEF)) {
1296:
1297: /* get the flags word: */
1298: TME_I825X6_READ16((rfd_address
1299: + TME_I825X6_RFD_EL_S_SF),
1300: el_s_sf);
1301:
1302: /* if AL-LOC is set to zero, the Ethernet/802.3 MAC header will be
1303: received into the Receive Frame Descriptor: */
1304: if (i825x6->tme_i825x6_al_loc == 0) {
1305:
1306: /* make a set of rx buffers out of the Ethernet header part of
1307: the Receive Frame Descriptor: */
1308: _tme_i825x6_rx_buffers_add(i825x6,
1309: (rfd_address
1310: + TME_I82586_RFD_RBD_ETH_HEADER),
1311: TME_ETHERNET_HEADER_SIZE,
1312: &_prev);
1313:
1314: /* account for the Receive Frame Descriptor header bytes in the
1315: Free Buffer List space and Receive Buffer size calculations: */
1316: i825x6->tme_i825x6_fbl_size += TME_ETHERNET_HEADER_SIZE;
1317: rbd_size = 0 - TME_ETHERNET_HEADER_SIZE;
1318: }
1319:
1320: /* take the Free Buffer List: */
1321: *_prev = i825x6->tme_i825x6_fbl;
1322: }
1323:
1324: /* get the Ethernet connection: */
1325: conn_eth = i825x6->tme_i825x6_eth_connection;
1326:
1327: /* unlock the mutex: */
1328: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
1329:
1330: /* do the callout: */
1331: resid = (conn_eth == NULL
1332: ? 0
1333: : ((*conn_eth->tme_ethernet_connection_read)
1334: (conn_eth,
1335: &frame_id,
1336: &rx_buffers->tme_i825x6_rx_buffer_frame_chunk,
1337: TME_ETHERNET_READ_NEXT)));
1338:
1339: /* lock the mutex: */
1340: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1341:
1342: /* if the read failed: */
1343: if (resid <= 0) {
1344:
1345: /* convention dictates that we forget that the connection was
1346: readable, which we already have done by clearing the
1347: CALLOUT_READ flag: */
1348: return (stat_cus_rus_t);
1349: }
1350:
1351: /* mark that we need to loop to callout to read more frames: */
1352: i825x6->tme_i825x6_callout_flags |= TME_I825X6_CALLOUT_READ;
1353:
1354: /* return now if the Receive Unit is Idle: */
1355: if ((stat_cus_rus_t & TME_I82586_SCB_RUS_MASK)
1356: == TME_I825X6_SCB_RUS_IDLE) {
1357: return (stat_cus_rus_t);
1358: }
1359:
1360: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
1361: 100, TME_OK,
1362: (&i825x6->tme_i825x6_element->tme_element_log_handle,
1363: "RU RFD 0x%06x el_s_sf 0x%04x",
1364: rfd_address,
1365: el_s_sf));
1366:
1367: /* we must have received more than just headers: */
1368: assert (resid > TME_ETHERNET_HEADER_SIZE);
1369:
1370: /* if we have a Receive Frame Descriptor: */
1371: if (rfd_address != TME_I825X6_RU_ADDRESS_UNDEF) {
1372:
1373: /* walk the rx buffers, stopping early only if we have exhausted
1374: the Ethernet frame *and* we have updated the last Receive
1375: Buffer used to receive it: */
1376: for (rx_buffer = rx_buffers;
1377: (rx_buffer != NULL
1378: && (resid > 0
1379: || rbd_size > 0)); ) {
1380:
1381: /* calculate the number of bytes used in this rx buffer. since
1382: a single Receive Buffer can be split into many rx buffers,
1383: the Ethernet frame may not fill all of them, so this can be
1384: zero: */
1385: rx_buffer_size
1386: = TME_MIN((unsigned int) resid,
1387: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes_count);
1388:
1389: /* this many more bytes have been received into this Receive Buffer: */
1390: rbd_size += rx_buffer_size;
1391:
1392: /* this many more bytes have been accounted for in the Ethernet frame: */
1393: resid -= rx_buffer_size;
1394:
1395: /* if this was a slow frame chunk: */
1396: if (rx_buffer->tme_i825x6_rx_buffer_rb_address
1397: != TME_I825X6_RU_ADDRESS_UNDEF) {
1398:
1399: /* DMA the contents out: */
1400: rc = tme_bus_device_dma_write_16(&i825x6->tme_i825x6_device,
1401: rx_buffer->tme_i825x6_rx_buffer_rb_address,
1402: rx_buffer_size,
1403: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes,
1404: TME_I825X6_LOCKS_DEFAULT);
1405: assert (rc == TME_OK);
1406: }
1407:
1408: /* if this was the last rx buffer for a Receive Buffer: */
1409: if (rx_buffer->tme_i825x6_rx_buffer_rbd_address
1410: != TME_I825X6_RU_ADDRESS_UNDEF) {
1411:
1412: /* make the EOF_F_ACT_COUNT field: */
1413: assert (rbd_size > 0 && rbd_size <= TME_I825X6_RBD_ACT_COUNT_MASK);
1414: eof_f_act_count = ((resid == 0
1415: ? TME_I825X6_RBD_EOF
1416: : 0)
1417: | TME_I825X6_RBD_F
1418: | rbd_size);
1419:
1420: /* write the EOF_F_ACT_COUNT field out to the Receive Buffer
1421: Descriptor: */
1422: TME_I825X6_WRITE16((rx_buffer->tme_i825x6_rx_buffer_rbd_address
1423: + TME_I825X6_RBD_EOF_F_ACT_COUNT),
1424: eof_f_act_count);
1425:
1426: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
1427: 100, TME_OK,
1428: (&i825x6->tme_i825x6_element->tme_element_log_handle,
1429: "RU RBD 0x%06x last-size 0x%04x eof_f_act_count 0x%04x",
1430: rx_buffer->tme_i825x6_rx_buffer_rbd_address,
1431: rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes_count,
1432: eof_f_act_count));
1433:
1434: /* we're starting on the next Receive Buffer: */
1435: rbd_size = 0;
1436: }
1437:
1438: /* free this rx buffer and move to the next rx buffer: */
1439: i825x6->tme_i825x6_fbl_size -= rx_buffer->tme_i825x6_rx_buffer_frame_chunk.tme_ethernet_frame_chunk_bytes_count;
1440: rx_buffer = _tme_i825x6_rx_buffer_free(i825x6, rx_buffer);
1441: }
1442:
1443: /* update the Free Buffer List: */
1444: assert ((rx_buffer != NULL) == (i825x6->tme_i825x6_fbl_size != 0));
1445: i825x6->tme_i825x6_fbl = rx_buffer;
1446:
1447: /* make the C_B_OK_STATUS field: */
1448: c_b_ok_status = (TME_I825X6_FLAG_C
1449: | (resid == 0
1450: ? TME_I825X6_FLAG_OK
1451: : TME_I825X6_RFD_STATUS_RNR));
1452:
1453: /* write the C_B_OK_STATUS field in the RFD: */
1454: TME_I825X6_WRITE16((rfd_address
1455: + TME_I825X6_RFD_C_B_OK_STATUS),
1456: c_b_ok_status);
1457:
1458: /* signal an interrupt: */
1459: stat_cus_rus_t |= TME_I825X6_SCB_STAT_FR;
1460:
1461: /* if EL is set, there is no next Receive Frame Descriptor,
1462: and when the Receive Unit tries to receive another frame
1463: it will go No Resources: */
1464: if (el_s_sf & TME_I825X6_FLAG_EL) {
1465: rfd_address = TME_I825X6_RU_ADDRESS_UNDEF;
1466: }
1467:
1468: /* otherwise, get the address of the next Receive Frame Descriptor: */
1469: else {
1470: TME_I825X6_READ16((rfd_address
1471: + TME_I82586_RFD_LINK_OFFSET),
1472: rfd_address);
1473: rfd_address += i825x6->tme_i825x6_scb_base;
1474: }
1475:
1476: /* set the next RFD address: */
1477: i825x6->tme_i825x6_rfd_address = rfd_address;
1478:
1479: /* if there is a next RFD address: */
1480: if (rfd_address != TME_I825X6_RU_ADDRESS_UNDEF) {
1481:
1482: /* refill the Free Buffer List: */
1483: rbd_offset_next = _tme_i825x6_fbl_refill(i825x6, FALSE);
1484:
1485: /* write the offset of the first free Receive Buffer Descriptor
1486: in the RBD Offset field in the RFD: */
1487: TME_I825X6_WRITE16((rfd_address
1488: + TME_I82586_RFD_RBD_OFFSET),
1489: rbd_offset_next);
1490: }
1491:
1492: /* if S is set, the Receive Unit becomes Suspended: */
1493: if (el_s_sf & TME_I825X6_FLAG_S) {
1494:
1495: /* the Receive Unit is now Suspended: */
1496: stat_cus_rus_t
1497: = ((stat_cus_rus_t
1498: & ~TME_I82586_SCB_RUS_MASK)
1499: | TME_I825X6_SCB_RUS_SUSPENDED);
1500: }
1501: }
1502:
1503: /* otherwise, we had no Receive Frame Descriptor, so we had
1504: to discard this packet entirely: */
1505: else {
1506:
1507: /* account for the discarded packet: */
1508: TME_I825X6_READ16((i825x6->tme_i825x6_scb_address
1509: + TME_I82586_SCB_ERRORS_RESOURCE),
1510: discards);
1511: discards++;
1512: TME_I825X6_WRITE16((i825x6->tme_i825x6_scb_address
1513: + TME_I82586_SCB_ERRORS_RESOURCE),
1514: discards);
1515: }
1516:
1517: /* if we ran out of resources: */
1518: if (resid > 0) {
1519:
1520: /* the receiver is now out of resources: */
1521: stat_cus_rus_t = ((stat_cus_rus_t
1522: & ~TME_I82586_SCB_RUS_MASK)
1523: | TME_I825X6_SCB_RUS_ERESOURCE);
1524: }
1525:
1526: /* done: */
1527: return (stat_cus_rus_t);
1528: }
1529:
1530: /* the i825x6 callout function. it must be called with the mutex locked: */
1531: static void
1532: _tme_i825x6_callout(struct tme_i825x6 *i825x6, int new_callouts)
1533: {
1534: struct tme_ethernet_connection *conn_eth;
1535: struct tme_bus_connection *conn_bus;
1536: int callouts, later_callouts;
1537: unsigned int ctrl;
1538: struct tme_ethernet_config config;
1539: int rc;
1540: tme_uint16_t stat_cus_rus_t;
1541: tme_uint16_t value16;
1542: int int_asserted;
1543: unsigned int address_i;
1544:
1545: /* add in any new callouts: */
1546: i825x6->tme_i825x6_callout_flags |= new_callouts;
1547:
1548: /* if this function is already running in another thread, simply
1549: return now. the other thread will do our work: */
1550: if (i825x6->tme_i825x6_callout_flags & TME_I825X6_CALLOUTS_RUNNING) {
1551: return;
1552: }
1553:
1554: /* callouts are now running: */
1555: i825x6->tme_i825x6_callout_flags |= TME_I825X6_CALLOUTS_RUNNING;
1556:
1557: /* assume that we won't need any later callouts: */
1558: later_callouts = 0;
1559:
1560: /* loop while callouts are needed: */
1561: for (; (callouts = i825x6->tme_i825x6_callout_flags) & TME_I825X6_CALLOUTS_MASK; ) {
1562:
1563: /* clear the needed callouts: */
1564: i825x6->tme_i825x6_callout_flags = callouts & ~TME_I825X6_CALLOUTS_MASK;
1565: callouts &= TME_I825X6_CALLOUTS_MASK;
1566:
1567: /* get this card's connection: */
1568: conn_eth = i825x6->tme_i825x6_eth_connection;
1569:
1570: /* get the current SCB status word. this word is referenced and
1571: updated throughout the body of this for loop; any changes made
1572: are written out at the bottom of the loop: */
1573: stat_cus_rus_t = i825x6->tme_i825x6_stat_cus_rus_t;
1574:
1575: /* if we need to handle a Channel Attention: */
1576: if (callouts & TME_I825X6_CALLOUT_CA) {
1577: stat_cus_rus_t = _tme_i825x6_callout_ca(i825x6, stat_cus_rus_t);
1578: if (stat_cus_rus_t == TME_I825X6_CA_RESET) {
1579: continue;
1580: }
1581: }
1582:
1583: /* if we need to run the Command Unit: */
1584: if (callouts & TME_I825X6_CALLOUT_CU) {
1585: stat_cus_rus_t = _tme_i825x6_callout_cu(i825x6, stat_cus_rus_t);
1586: }
1587:
1588: /* if we need to call out new control information: */
1589: if (callouts & TME_I825X6_CALLOUT_CTRL) {
1590:
1591: /* form the new ctrl: */
1592: ctrl = 0;
1593: if (((stat_cus_rus_t
1594: & TME_I825X6_SCB_CUS_MASK)
1595: == TME_I825X6_SCB_CUS_ACTIVE)
1596: && ((i825x6->tme_i825x6_el_s_i_cmd
1597: & TME_I825X6_CB_CMD_MASK)
1598: == TME_I825X6_CB_CMD_TRANSMIT)) {
1599: ctrl |= TME_ETHERNET_CTRL_OK_READ;
1600: }
1601:
1602: /* unlock the mutex: */
1603: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
1604:
1605: /* do the callout: */
1606: rc = (conn_eth != NULL
1607: ? ((*conn_eth->tme_ethernet_connection_ctrl)
1608: (conn_eth,
1609: ctrl))
1610: : TME_OK);
1611:
1612: /* lock the mutex: */
1613: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1614:
1615: /* if the callout was unsuccessful, remember that at some later
1616: time this callout should be attempted again: */
1617: if (rc != TME_OK) {
1618: later_callouts |= TME_I825X6_CALLOUT_CTRL;
1619: }
1620: }
1621:
1622: /* if we need to call out new config information: */
1623: if (callouts & TME_I825X6_CALLOUT_CONFIG) {
1624:
1625: /* form the new config: */
1626: memset(&config, 0, sizeof(config));
1627:
1628: /* our Ethernet addresses: */
1629: config.tme_ethernet_config_addr_count = i825x6->tme_i825x6_address_count;
1630: config.tme_ethernet_config_addrs
1631: = tme_new(const tme_uint8_t *,
1632: i825x6->tme_i825x6_address_count);
1633: for (address_i = 0;
1634: address_i < i825x6->tme_i825x6_address_count;
1635: address_i++) {
1636: config.tme_ethernet_config_addrs[address_i]
1637: = &i825x6->tme_i825x6_addresses[(address_i
1638: * TME_ETHERNET_ADDR_SIZE)];
1639: }
1640:
1641: /* our config flags: */
1642: config.tme_ethernet_config_flags
1643: = (TME_ETHERNET_CONFIG_NORMAL
1644: | (i825x6->tme_i825x6_prm
1645: ? TME_ETHERNET_CONFIG_PROMISC
1646: : 0));
1647:
1648: /* unlock the mutex: */
1649: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
1650:
1651: /* do the callout: */
1652: rc = (conn_eth == NULL
1653: ? TME_OK
1654: : ((*conn_eth->tme_ethernet_connection_config)
1655: (conn_eth,
1656: &config)));
1657:
1658: /* lock the mutex: */
1659: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1660:
1661: /* free the Ethernet address pointer array: */
1662: tme_free(config.tme_ethernet_config_addrs);
1663:
1664: /* if the callout was unsuccessful, remember that at some later
1665: time this callout should be attempted again: */
1666: if (rc != TME_OK) {
1667: later_callouts |= TME_I825X6_CALLOUT_CONFIG;
1668: }
1669: }
1670:
1671: /* if the Ethernet is readable: */
1672: if (callouts & TME_I825X6_CALLOUT_READ) {
1673:
1674: /* if the Receive Unit is Suspended, make this callout later: */
1675: if ((stat_cus_rus_t
1676: & TME_I82586_SCB_RUS_MASK)
1677: == TME_I825X6_SCB_RUS_SUSPENDED) {
1678: later_callouts |= TME_I825X6_CALLOUT_READ;
1679: }
1680:
1681: /* otherwise, the Receive Unit is not Suspended, so read this
1682: frame. the frame will not be stored if the Receive Unit is
1683: in the Idle or No Resources state: */
1684: else {
1685: stat_cus_rus_t = _tme_i825x6_callout_ru(i825x6, stat_cus_rus_t);
1686: }
1687: }
1688:
1689: /* note if the Command Unit left the Active state: */
1690: if (((i825x6->tme_i825x6_stat_cus_rus_t
1691: & TME_I825X6_SCB_CUS_MASK)
1692: == TME_I825X6_SCB_CUS_ACTIVE)
1693: && ((stat_cus_rus_t
1694: & TME_I825X6_SCB_CUS_MASK)
1695: != TME_I825X6_SCB_CUS_ACTIVE)) {
1696: stat_cus_rus_t |= TME_I825X6_SCB_STAT_CNA;
1697: }
1698:
1699: /* note if the Receive Unit left the Ready state: */
1700: if (((i825x6->tme_i825x6_stat_cus_rus_t
1701: & TME_I82586_SCB_RUS_MASK)
1702: == TME_I825X6_SCB_RUS_READY)
1703: && ((stat_cus_rus_t
1704: & TME_I82586_SCB_RUS_MASK)
1705: != TME_I825X6_SCB_RUS_READY)) {
1706: stat_cus_rus_t |= TME_I825X6_SCB_STAT_RNR;
1707: }
1708:
1709: /* if our Status bits have changed such that our interrupt signal
1710: changes, we need to call out an interrupt: */
1711: if (!(i825x6->tme_i825x6_stat_cus_rus_t
1712: & TME_I825X6_SCB_STAT_MASK)
1713: != !(stat_cus_rus_t
1714: & TME_I825X6_SCB_STAT_MASK)) {
1715: i825x6->tme_i825x6_callout_flags |= TME_I825X6_CALLOUT_INT;
1716: }
1717:
1718: /* if our SCB status word has changed, write it out: */
1719: if (stat_cus_rus_t != i825x6->tme_i825x6_stat_cus_rus_t) {
1720:
1721: /* log: */
1722: tme_log(&i825x6->tme_i825x6_element->tme_element_log_handle,
1723: 100, TME_OK,
1724: (&i825x6->tme_i825x6_element->tme_element_log_handle,
1725: "SCB status 0x%04x -> 0x%04x",
1726: i825x6->tme_i825x6_stat_cus_rus_t,
1727: stat_cus_rus_t));
1728:
1729: TME_I825X6_WRITE16((i825x6->tme_i825x6_scb_address
1730: + TME_I825X6_SCB_STAT_CUS_RUS_T),
1731: stat_cus_rus_t);
1732: i825x6->tme_i825x6_stat_cus_rus_t = stat_cus_rus_t;
1733: }
1734:
1735: /* if we need to call out a change to our interrupt signal: */
1736: if (callouts & TME_I825X6_CALLOUT_INT) {
1737:
1738: /* see if the interrupt signal should be asserted or negated: */
1739: int_asserted = (stat_cus_rus_t & TME_I825X6_SCB_STAT_MASK);
1740:
1741: /* unlock our mutex: */
1742: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
1743:
1744: /* get our bus connection: */
1745: conn_bus = TME_ATOMIC_READ(struct tme_bus_connection *,
1746: i825x6->tme_i825x6_device.tme_bus_device_connection);
1747:
1748: /* call out the bus interrupt signal edge: */
1749: rc = (*conn_bus->tme_bus_signal)
1750: (conn_bus,
1751: TME_BUS_SIGNAL_INT_UNSPEC
1752: | (int_asserted
1753: ? TME_BUS_SIGNAL_LEVEL_ASSERTED
1754: : TME_BUS_SIGNAL_LEVEL_NEGATED));
1755:
1756: /* lock our mutex: */
1757: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1758:
1759: /* if this callout failed, remember that at some later time this
1760: callout should be attempted again: */
1761: if (rc != TME_OK) {
1762: later_callouts |= TME_I825X6_CALLOUT_INT;
1763: }
1764: }
1765: }
1766:
1767: /* put in any later callouts, and clear that callouts are running: */
1768: i825x6->tme_i825x6_callout_flags = later_callouts;
1769: }
1770:
1771: /* the i825x6 bus signal handler: */
1772: static int
1773: _tme_i825x6_signal(void *_i825x6,
1774: unsigned int signal)
1775: {
1776: struct tme_i825x6 *i825x6;
1777: int new_callouts;
1778: unsigned int level;
1779:
1780: /* recover our data structure: */
1781: i825x6 = (struct tme_i825x6 *) _i825x6;
1782:
1783: /* assume we won't need any new callouts: */
1784: new_callouts = 0;
1785:
1786: /* lock the mutex: */
1787: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1788:
1789: /* take out the signal level: */
1790: level = signal & TME_BUS_SIGNAL_LEVEL_MASK;
1791: signal ^= level;
1792:
1793: /* dispatch on the generic bus signals: */
1794: switch (signal) {
1795: case TME_BUS_SIGNAL_RESET:
1796: if (level == TME_BUS_SIGNAL_LEVEL_ASSERTED) {
1797: _tme_i825x6_reset(i825x6);
1798: }
1799: break;
1800: default:
1801: break;
1802: }
1803:
1804: /* dispatch on the i825x6 bus signals: */
1805: if (signal >= i825x6->tme_i825x6_bus_signals.tme_bus_signals_first) {
1806: switch (signal - i825x6->tme_i825x6_bus_signals.tme_bus_signals_first) {
1807:
1808: case TME_I825X6_SIGNAL_CA:
1809: if (level == TME_BUS_SIGNAL_LEVEL_ASSERTED) {
1810: new_callouts |= TME_I825X6_CALLOUT_CA;
1811: }
1812: break;
1813:
1814: case TME_I825X6_SIGNAL_LOOP:
1815: #if 0
1816: if (level == TME_BUS_SIGNAL_LEVEL_ASSERTED) {
1817: abort();
1818: }
1819: #endif
1820: break;
1821:
1822: default:
1823: break;
1824: }
1825: }
1826:
1827: /* make any new callouts: */
1828: _tme_i825x6_callout(i825x6, new_callouts);
1829:
1830: /* unlock the mutex: */
1831: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
1832:
1833: /* no faults: */
1834: return (TME_OK);
1835: }
1836:
1837: /* this is called when a device changes its configuration: */
1838: static int
1839: _tme_i825x6_config(struct tme_ethernet_connection *conn_eth,
1840: struct tme_ethernet_config *config)
1841: {
1842: /* we don't care when other devices on the Ethernet
1843: reconfigure themselves: */
1844: return (TME_OK);
1845: }
1846:
1847: /* this is called when control lines change: */
1848: static int
1849: _tme_i825x6_ctrl(struct tme_ethernet_connection *conn_eth,
1850: unsigned int ctrl)
1851: {
1852: struct tme_i825x6 *i825x6;
1853: int new_callouts;
1854:
1855: /* recover our data structures: */
1856: i825x6 = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private;
1857:
1858: /* assume that we won't need any new callouts: */
1859: new_callouts = 0;
1860:
1861: /* lock the mutex: */
1862: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1863:
1864: /* if this connection is readable, call out a read: */
1865: if (ctrl & TME_ETHERNET_CTRL_OK_READ) {
1866: new_callouts |= TME_I825X6_CALLOUT_READ;
1867: }
1868:
1869: /* make any new callouts: */
1870: _tme_i825x6_callout(i825x6, new_callouts);
1871:
1872: /* unlock the mutex: */
1873: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
1874:
1875: return (TME_OK);
1876: }
1877:
1878: /* this is called to read frames (from the i825x6 perspective, to transmit them): */
1879: static int
1880: _tme_i825x6_read(struct tme_ethernet_connection *conn_eth,
1881: tme_ethernet_fid_t *_frame_id,
1882: struct tme_ethernet_frame_chunk *frame_chunks,
1883: unsigned int flags)
1884: {
1885: struct tme_i825x6 *i825x6;
1886: int new_callouts;
1887: struct tme_ethernet_frame_chunk frame_chunk_buffer;
1888: tme_uint32_t tbd_address, tb_address;
1889: tme_uint16_t eof_size;
1890: tme_uint16_t c_b_ok_a;
1891: tme_uint16_t value16;
1892: tme_uint32_t value32;
1893: int rc, err;
1894:
1895: /* recover our data structures: */
1896: i825x6 = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private;
1897:
1898: /* assume that we won't need any new callouts: */
1899: new_callouts = 0;
1900:
1901: /* start our local copy of the caller's frame chunks: */
1902: if (frame_chunks != NULL) {
1903: frame_chunk_buffer = *frame_chunks;
1904: }
1905: else {
1906: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes_count = 0;
1907: }
1908: frame_chunks = &frame_chunk_buffer;
1909:
1910: /* lock our mutex: */
1911: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
1912:
1913: /* assume that we will have no packet to transmit: */
1914: rc = 0;
1915:
1916: /* if we have a packet to transmit: */
1917: if ((i825x6->tme_i825x6_el_s_i_cmd
1918: & TME_I825X6_CB_CMD_MASK)
1919: == TME_I825X6_CB_CMD_TRANSMIT) {
1920:
1921: /* assume that we will succeed: */
1922: err = TME_OK;
1923: do {
1924:
1925: /* a helper macro for DMAing and copying data into chunks: */
1926: #define CHUNKS_DMA_TX(addr, size) \
1927: err = _tme_i825x6_chunks_dma_tx(i825x6, frame_chunks, (addr), (size)); \
1928: if (err != TME_OK) break; \
1929: rc += size
1930: #define CHUNKS_MEM_TX(data, size) \
1931: _tme_i825x6_chunks_mem_tx(frame_chunks, (data), (size)); \
1932: rc += size
1933:
1934: /* if AL-LOC is set to zero, add the Ethernet/802.3 MAC header: */
1935: if (i825x6->tme_i825x6_al_loc == 0) {
1936:
1937: /* the destination address: */
1938: CHUNKS_DMA_TX(i825x6->tme_i825x6_cb_address + TME_I82586_TCB_ADDR_DEST,
1939: TME_ETHERNET_ADDR_SIZE);
1940:
1941: /* our source address (our Individual Address): */
1942: CHUNKS_MEM_TX(&i825x6->tme_i825x6_addresses[TME_ETHERNET_ADDR_SIZE],
1943: TME_ETHERNET_ADDR_SIZE);
1944:
1945: /* the length field: */
1946: CHUNKS_DMA_TX(i825x6->tme_i825x6_cb_address + TME_I82586_TCB_LENGTH,
1947: TME_ETHERNET_LENGTH_SIZE);
1948: }
1949:
1950: /* the transmit buffers: */
1951: TME_I825X6_READ16((i825x6->tme_i825x6_cb_address
1952: + TME_I82586_TCB_TBD_OFFSET),
1953: tbd_address);
1954: for (; tbd_address != 0xffff; ) {
1955: tbd_address += i825x6->tme_i825x6_scb_base;
1956:
1957: TME_I825X6_READ16((tbd_address
1958: + TME_I82586_TBD_EOF_SIZE),
1959: eof_size);
1960: TME_I82586_READ24((tbd_address
1961: + TME_I82586_TBD_TB_ADDRESS),
1962: tb_address);
1963:
1964: /* the transmit buffer contents: */
1965: CHUNKS_DMA_TX(tb_address,
1966: (eof_size & TME_I82586_TBD_SIZE_MASK));
1967:
1968: /* the next transmit buffer: */
1969: if (eof_size & TME_I82586_TBD_EOF) {
1970: break;
1971: }
1972: TME_I825X6_READ16((tbd_address
1973: + TME_I82586_TBD_TBD_OFFSET),
1974: tbd_address);
1975: }
1976:
1977: #undef CHUNKS_DMA_TX
1978: #undef CHUNKS_MEM_TX
1979:
1980: } while (/* CONSTCOND */ 0);
1981:
1982: /* get the CB status word and clear all of the transmit status bits: */
1983: c_b_ok_a
1984: = (i825x6->tme_i825x6_c_b_ok_a
1985: & ~TME_I825X6_TCB_STATUS_MASK);
1986:
1987: /* if we got a bus error: */
1988: if (err != TME_OK) {
1989:
1990: /* set the DMA underrun transmit status bit: */
1991: c_b_ok_a |= TME_I825X6_TCB_STATUS_UNDERRUN;
1992:
1993: /* return an error to our caller: */
1994: rc = -ENOENT;
1995: }
1996:
1997: /* update the CB status word: */
1998: i825x6->tme_i825x6_c_b_ok_a = c_b_ok_a;
1999:
2000: /* run the Command Unit: */
2001: new_callouts |= TME_I825X6_CALLOUT_CU;
2002:
2003: /* we no longer have a packet to transmit: */
2004: i825x6->tme_i825x6_el_s_i_cmd
2005: = ((i825x6->tme_i825x6_el_s_i_cmd
2006: & ~TME_I825X6_CB_CMD_MASK)
2007: | TME_I825X6_CB_CMD_NOP);
2008: }
2009:
2010: /* make any new callouts: */
2011: _tme_i825x6_callout(i825x6, new_callouts);
2012:
2013: /* unlock our mutex: */
2014: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
2015:
2016: /* done: */
2017: return (rc);
2018: }
2019:
2020: /* this makes a new Ethernet connection: */
2021: static int
2022: _tme_i825x6_connection_make_eth(struct tme_connection *conn, unsigned int state)
2023: {
2024: struct tme_i825x6 *i825x6;
2025: struct tme_ethernet_connection *conn_eth;
2026: struct tme_ethernet_connection *conn_eth_other;
2027:
2028: /* recover our data structures: */
2029: i825x6 = conn->tme_connection_element->tme_element_private;
2030: conn_eth = (struct tme_ethernet_connection *) conn;
2031: conn_eth_other = (struct tme_ethernet_connection *) conn->tme_connection_other;
2032:
2033: /* both sides must be Ethernet connections: */
2034: assert(conn->tme_connection_type == TME_CONNECTION_ETHERNET);
2035: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_ETHERNET);
2036:
2037: /* we're always set up to answer calls across the connection, so we
2038: only have to do work when the connection has gone full, namely
2039: taking the other side of the connection: */
2040: if (state == TME_CONNECTION_FULL) {
2041:
2042: /* lock our mutex: */
2043: tme_mutex_lock(&i825x6->tme_i825x6_mutex);
2044:
2045: /* save our connection: */
2046: i825x6->tme_i825x6_eth_connection = conn_eth_other;
2047:
2048: /* unlock our mutex: */
2049: tme_mutex_unlock(&i825x6->tme_i825x6_mutex);
2050: }
2051:
2052: return (TME_OK);
2053: }
2054:
2055: /* this makes a new bus connection: */
2056: static int
2057: _tme_i825x6_connection_make_bus(struct tme_connection *conn,
2058: unsigned int state)
2059: {
2060: struct tme_i825x6 *i825x6;
2061: struct tme_bus_connection *conn_bus;
2062: int rc;
2063:
2064: /* recover our data structure: */
2065: i825x6 = conn->tme_connection_element->tme_element_private;
2066:
2067: /* call the bus device connection maker: */
2068: rc = tme_bus_device_connection_make(conn, state);
2069:
2070: /* if the full connection was successful, and we don't have a TLB
2071: hash yet, allocate it and add our bus signals: */
2072: if (rc == TME_OK
2073: && state == TME_CONNECTION_FULL
2074: && TME_ATOMIC_READ(struct tme_bus_tlb *,
2075: i825x6->tme_i825x6_tlb_hash) == NULL) {
2076:
2077: /* get our bus connection: */
2078: conn_bus
2079: = TME_ATOMIC_READ(struct tme_bus_connection *,
2080: i825x6->tme_i825x6_device.tme_bus_device_connection);
2081:
2082: /* allocate the TLB set: */
2083: rc = ((*conn_bus->tme_bus_tlb_set_allocate)
2084: (conn_bus,
2085: TME_I825X6_TLB_HASH_SIZE,
2086: sizeof(struct tme_bus_tlb),
2087: TME_ATOMIC_POINTER(&i825x6->tme_i825x6_tlb_hash)));
2088: assert (rc == TME_OK);
2089:
2090: /* add our bus signals: */
2091: i825x6->tme_i825x6_bus_signals = _tme_i825x6_bus_signals;
2092: rc = ((*conn_bus->tme_bus_signals_add)
2093: (conn_bus,
2094: &i825x6->tme_i825x6_bus_signals));
2095: assert (rc == TME_OK);
2096: }
2097:
2098: return (rc);
2099: }
2100:
2101: /* this breaks a connection: */
2102: static int
2103: _tme_i825x6_connection_break(struct tme_connection *conn, unsigned int state)
2104: {
2105: abort();
2106: }
2107:
2108: /* this makes a new connection side for a i825x6: */
2109: static int
2110: _tme_i825x6_connections_new(struct tme_element *element,
2111: const char * const *args,
2112: struct tme_connection **_conns,
2113: char **_output)
2114: {
2115: struct tme_i825x6 *i825x6;
2116: struct tme_ethernet_connection *conn_eth;
2117: struct tme_connection *conn;
2118: int rc;
2119:
2120: /* recover our data structure: */
2121: i825x6 = (struct tme_i825x6 *) element->tme_element_private;
2122:
2123: /* make the generic bus device connection side: */
2124: rc = tme_bus_device_connections_new(element, args, _conns, _output);
2125: if (rc != TME_OK) {
2126: return (rc);
2127: }
2128:
2129: /* since we need to allocate our TLB hash and add our signals sets
2130: when we make our bus connection, make sure any generic bus device
2131: connection sides use our connection maker: */
2132: for (conn = *_conns;
2133: conn != NULL;
2134: conn = conn->tme_connection_next) {
2135: if ((conn->tme_connection_type
2136: == TME_CONNECTION_BUS_GENERIC)
2137: && (conn->tme_connection_make
2138: == tme_bus_device_connection_make)) {
2139: conn->tme_connection_make
2140: = _tme_i825x6_connection_make_bus;
2141: }
2142: }
2143:
2144: /* if we don't have an Ethernet connection, make one: */
2145: if (i825x6->tme_i825x6_eth_connection == NULL) {
2146:
2147: /* allocate the new Ethernet connection: */
2148: conn_eth = tme_new0(struct tme_ethernet_connection, 1);
2149: conn = &conn_eth->tme_ethernet_connection;
2150:
2151: /* fill in the generic connection: */
2152: conn->tme_connection_next = *_conns;
2153: conn->tme_connection_type = TME_CONNECTION_ETHERNET;
2154: conn->tme_connection_score = tme_ethernet_connection_score;
2155: conn->tme_connection_make = _tme_i825x6_connection_make_eth;
2156: conn->tme_connection_break = _tme_i825x6_connection_break;
2157:
2158: /* fill in the Ethernet connection: */
2159: conn_eth->tme_ethernet_connection_config = _tme_i825x6_config;
2160: conn_eth->tme_ethernet_connection_ctrl = _tme_i825x6_ctrl;
2161: conn_eth->tme_ethernet_connection_read = _tme_i825x6_read;
2162:
2163: /* return the connection side possibility: */
2164: *_conns = conn;
2165: }
2166:
2167: /* done: */
2168: return (TME_OK);
2169: }
2170:
2171: /* the new i82586 function: */
2172: TME_ELEMENT_X_NEW_DECL(tme_ic_,i825x6,i82586) {
2173: struct tme_i825x6 *i825x6;
2174: int arg_i;
2175: int usage;
2176:
2177: /* check our arguments: */
2178: usage = 0;
2179: arg_i = 1;
2180: for (;;) {
2181:
2182: if (0) {
2183: }
2184:
2185: /* if we ran out of arguments: */
2186: else if (args[arg_i] == NULL) {
2187:
2188: break;
2189: }
2190:
2191: /* otherwise this is a bad argument: */
2192: else {
2193: tme_output_append_error(_output,
2194: "%s %s, ",
2195: args[arg_i],
2196: _("unexpected"));
2197: usage = TRUE;
2198: break;
2199: }
2200: }
2201:
2202: if (usage) {
2203: tme_output_append_error(_output,
2204: "%s %s",
2205: _("usage:"),
2206: args[0]);
2207: return (EINVAL);
2208: }
2209:
2210: /* start the i825x6 structure: */
2211: i825x6 = tme_new0(struct tme_i825x6, 1);
2212: i825x6->tme_i825x6_element = element;
2213: tme_mutex_init(&i825x6->tme_i825x6_mutex);
2214: i825x6->tme_i825x6_address_count = 2;
2215: i825x6->tme_i825x6_addresses
2216: = tme_new(tme_uint8_t,
2217: i825x6->tme_i825x6_address_count
2218: * TME_ETHERNET_ADDR_SIZE);
2219:
2220: /* initialize our simple bus device descriptor: */
2221: i825x6->tme_i825x6_device.tme_bus_device_element = element;
2222: i825x6->tme_i825x6_device.tme_bus_device_signal = _tme_i825x6_signal;
2223: i825x6->tme_i825x6_device.tme_bus_device_lock = _tme_i825x6_lock;
2224: i825x6->tme_i825x6_device.tme_bus_device_unlock = _tme_i825x6_unlock;
2225: i825x6->tme_i825x6_device.tme_bus_device_tlb_hash = _tme_i825x6_tlb_hash;
2226: i825x6->tme_i825x6_device.tme_bus_device_router = tme_bus_device_router_16el;
2227:
2228: /* fill the element: */
2229: element->tme_element_private = i825x6;
2230: element->tme_element_connections_new = _tme_i825x6_connections_new;
2231:
2232: /* reset the i825x6: */
2233: _tme_i825x6_reset(i825x6);
2234:
2235: return (TME_OK);
2236: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.