src/BeOS/ether_beos.cpp

/*
 *  ether_beos.cpp - SheepShaver Ethernet Device Driver (DLPI), BeOS specific stuff
 *
 *  SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"
#include "ether.h"
#include "ether_defs.h"
#include "prefs.h"
#include "xlowmem.h"
#include "main.h"
#include "user_strings.h"
#include "sheep_net.h"

#define DEBUG 0
#include "debug.h"

#define STATISTICS 0
#define MONITOR 0


// Global variables
static thread_id read_thread;                           // Packet receiver thread
static bool ether_thread_active = true;         // Flag for quitting the receiver thread

static area_id buffer_area;                                     // Packet buffer area
static net_buffer *net_buffer_ptr;                      // Pointer to packet buffer
static sem_id read_sem, write_sem;                      // Semaphores to trigger packet reading/writing
static uint32 rd_pos;                                           // Current read position in packet buffer
static uint32 wr_pos;                                           // Current write position in packet buffer

static bool net_open = false;                           // Flag: initialization succeeded, network device open


// Prototypes
static status_t AO_receive_thread(void *data);


/*
 *  Initialize ethernet
 */

void EtherInit(void)
{
        // Do nothing if the user disabled the network
        if (PrefsFindBool("nonet"))
                return;

        // find net-server team
i_wanna_try_that_again:
        bool found_add_on = false;
        team_info t_info;
        int32 t_cookie = 0;
        image_info i_info;
        int32 i_cookie = 0;
        while (get_next_team_info(&t_cookie, &t_info) == B_NO_ERROR) {
                if (strstr(t_info.args,"net_server")!=NULL) {
                        // check if sheep_net add-on is loaded
                        while (get_next_image_info(t_info.team,&i_cookie,&i_info) == B_NO_ERROR) {
                                if (strstr(i_info.name,"sheep_net")!=NULL) {
                                        found_add_on = true;
                                        break;                                  
                                }
                        }
                } 
                if (found_add_on) break;
        }
        if (!found_add_on) {

                // Search for sheep_net in network config file
                char str[1024];
                bool sheep_net_found = false;
                FILE *fin = fopen("/boot/home/config/settings/network", "r");
                while (!feof(fin)) {
                        fgets(str, 1024, fin);
                        if (strstr(str, "PROTOCOLS"))
                                if (strstr(str, "sheep_net"))
                                        sheep_net_found = true;
                }
                fclose(fin);

                // It was found, so something else must be wrong
                if (sheep_net_found) {
                        WarningAlert(GetString(STR_NO_NET_ADDON_WARN));
                        return;
                }

                // Not found, inform the user
                if (!ChoiceAlert(GetString(STR_NET_CONFIG_MODIFY_WARN), GetString(STR_OK_BUTTON), GetString(STR_CANCEL_BUTTON)))
                        return;

                // Change the network config file and restart the network
                fin = fopen("/boot/home/config/settings/network", "r");
                FILE *fout = fopen("/boot/home/config/settings/network.2", "w");
                bool global_found = false;
                bool modified = false;
                while (!feof(fin)) {
                        str[0] = 0;
                        fgets(str, 1024, fin);
                        if (!global_found && strstr(str, "GLOBAL:")) {
                                global_found = true;
                        } else if (global_found && !modified && strstr(str, "PROTOCOLS")) {
                                str[strlen(str)-1] = 0;
                                strcat(str, " sheep_net\n");
                                modified = true;
                        } else if (global_found && !modified && strlen(str) > 2 && str[strlen(str) - 2] == ':') {
                                fputs("\tPROTOCOLS = sheep_net\n", fout);
                                modified = true;
                        }
                        fputs(str, fout);
                }
                if (!modified)
                        fputs("\tPROTOCOLS = sheep_net\n", fout);
                fclose(fout);
                fclose(fin);
                remove("/boot/home/config/settings/network.orig");
                rename("/boot/home/config/settings/network", "/boot/home/config/settings/network.orig");
                rename("/boot/home/config/settings/network.2", "/boot/home/config/settings/network");

                app_info ai;
                if (be_roster->GetAppInfo("application/x-vnd.Be-NETS", &ai) == B_OK) {
                        BMessenger msg(NULL, ai.team);
                        if (msg.IsValid()) {
                                while (be_roster->IsRunning("application/x-vnd.Be-NETS")) {
                                        msg.SendMessage(B_QUIT_REQUESTED);
                                        snooze(500000);
                                }
                        }
                }
                BPath path;
                find_directory(B_BEOS_BOOT_DIRECTORY, &path);
                path.Append("Netscript");
                char *argv[3] = {"/bin/sh", (char *)path.Path(), NULL};
                thread_id net_server = load_image(2, argv, environ);
                resume_thread(net_server);
                status_t l;
                wait_for_thread(net_server, &l);
                goto i_wanna_try_that_again;
        }

        // Set up communications with add-on
        area_id handler_buffer;
        if ((handler_buffer = find_area("packet buffer")) < B_NO_ERROR) {
                WarningAlert(GetString(STR_NET_ADDON_INIT_FAILED));
                return;
        }
        if ((buffer_area = clone_area("local packet buffer", &net_buffer_ptr, B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, handler_buffer)) < B_NO_ERROR) {
                D(bug("EtherInit: couldn't clone packet area\n"));
                WarningAlert(GetString(STR_NET_ADDON_CLONE_FAILED));
                return;
        }
        if ((read_sem = create_sem(0, "ether read")) < B_NO_ERROR) {
                printf("FATAL: can't create Ethernet semaphore\n");
                return;
        }
        net_buffer_ptr->read_sem = read_sem;
        write_sem = net_buffer_ptr->write_sem;
        read_thread = spawn_thread(AO_receive_thread, "ether read", B_URGENT_DISPLAY_PRIORITY, NULL);
        resume_thread(read_thread);
        for (int i=0; i<WRITE_PACKET_COUNT; i++)
                net_buffer_ptr->write[i].cmd = IN_USE | (ACTIVATE_SHEEP_NET << 8);
        rd_pos = wr_pos = 0;
        release_sem(write_sem);

        // Everything OK
        net_open = true;
}


/*
 *  Exit ethernet
 */

void EtherExit(void)
{
        if (net_open) {

                // Close communications with add-on
                for (int i=0; i<WRITE_PACKET_COUNT; i++)
                        net_buffer_ptr->write[i].cmd = IN_USE | (DEACTIVATE_SHEEP_NET << 8);
                release_sem(write_sem);

                // Quit receiver thread
                ether_thread_active = false;
                status_t result;
                release_sem(read_sem);
                while (wait_for_thread(read_thread, &result) == B_INTERRUPTED) ;

                delete_sem(read_sem);
                delete_area(buffer_area);
        }
        
#if STATISTICS
        // Show statistics
        printf("%ld messages put on write queue\n", num_wput);
        printf("%ld error acks\n", num_error_acks);
        printf("%ld packets transmitted (%ld raw, %ld normal)\n", num_tx_packets, num_tx_raw_packets, num_tx_normal_packets);
        printf("%ld tx packets dropped because buffer full\n", num_tx_buffer_full);
        printf("%ld packets received\n", num_rx_packets);
        printf("%ld packets passed upstream (%ld Fast Path, %ld normal)\n", num_rx_fastpath + num_unitdata_ind, num_rx_fastpath, num_unitdata_ind);
        printf("EtherIRQ called %ld times\n", num_ether_irq);
        printf("%ld rx packets dropped due to low memory\n", num_rx_no_mem);
        printf("%ld rx packets dropped because no stream found\n", num_rx_dropped);
        printf("%ld rx packets dropped because stream not ready\n", num_rx_stream_not_ready);
        printf("%ld rx packets dropped because no memory for unitdata_ind\n", num_rx_no_unitdata_mem);
#endif
}


/*
 *  Ask add-on for ethernet hardware address
 */

void AO_get_ethernet_address(uint8 *addr)
{
        if (net_open) {
                OTCopy48BitAddress(net_buffer_ptr->ether_addr, addr);
        } else {
                addr[0] = 0x12;
                addr[1] = 0x34;
                addr[2] = 0x56;
                addr[3] = 0x78;
                addr[4] = 0x9a;
                addr[5] = 0xbc;
        }
        D(bug("AO_get_ethernet_address: got address %02x%02x%02x%02x%02x%02x\n", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]));
}


/*
 *  Tell add-on to enable multicast address
 */

void AO_enable_multicast(uint8 *addr)
{
        D(bug("AO_enable_multicast\n"));
        if (net_open) {
                net_packet *p = &net_buffer_ptr->write[wr_pos];
                if (p->cmd & IN_USE) {
                        D(bug("WARNING: couldn't enable multicast address\n"));
                } else {
                        memcpy(p->data, addr, 6);
                        p->length = 6;
                        p->cmd = IN_USE | (ADD_MULTICAST << 8);
                        wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
                        release_sem(write_sem);
                }
        }
}


/*
 *  Tell add-on to disable multicast address
 */

void AO_disable_multicast(uint8 *addr)
{
        D(bug("AO_disable_multicast\n"));
        if (net_open) {
                net_packet *p = &net_buffer_ptr->write[wr_pos];
                if (p->cmd & IN_USE) {
                        D(bug("WARNING: couldn't enable multicast address\n"));
                } else {
                        memcpy(p->data, addr, 6);
                        p->length = 6;
                        p->cmd = IN_USE | (REMOVE_MULTICAST << 8);
                        wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
                        release_sem(write_sem);
                }
                D(bug("WARNING: couldn't disable multicast address\n"));
        }
}


/*
 *  Tell add-on to transmit one packet
 */

void AO_transmit_packet(mblk_t *mp)
{
        D(bug("AO_transmit_packet\n"));
        if (net_open) {
                net_packet *p = &net_buffer_ptr->write[wr_pos];
                if (p->cmd & IN_USE) {
                        D(bug("WARNING: couldn't transmit packet (buffer full)\n"));
                        num_tx_buffer_full++;
                } else {
                        D(bug(" write packet pos %d\n", i));
                        num_tx_packets++;

                        // Copy packet to buffer
                        uint8 *start;
                        uint8 *bp = start = p->data;
                        while (mp) {
                                uint32 size = mp->b_wptr - mp->b_rptr;
                                memcpy(bp, mp->b_rptr, size);
                                bp += size;
                                mp = mp->b_cont;
                        }

#if MONITOR
                        bug("Sending Ethernet packet:\n");
                        for (int i=0; i<(uint32)(bp - start); i++) {
                                bug("%02lx ", start[i]);
                        }
                        bug("\n");
#endif

                        // Notify add-on
                        p->length = (uint32)(bp - start);
                        p->cmd = IN_USE | (SHEEP_PACKET << 8);
                        wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
                        release_sem(write_sem);
                }
        }
}


/*
 *  Packet reception thread
 */

static status_t AO_receive_thread(void *data)
{
        while (ether_thread_active) {
                if (net_buffer_ptr->read[rd_pos].cmd & IN_USE) {
                        if (ether_driver_opened) {
                                D(bug(" packet received, triggering Ethernet interrupt\n"));
                                SetInterruptFlag(INTFLAG_ETHER);
                                TriggerInterrupt();
                        }
                }
                acquire_sem_etc(read_sem, 1, B_TIMEOUT, 25000);
        }
        return 0;
}


/*
 *  Ethernet interrupt
 */

void EtherIRQ(void)
{
        D(bug("EtherIRQ\n"));
        num_ether_irq++;
        OTEnterInterrupt();

        // Send received packets to OpenTransport
        net_packet *p = &net_buffer_ptr->read[rd_pos];
        while (p->cmd & IN_USE) {
                if ((p->cmd >> 8) == SHEEP_PACKET) {
                        num_rx_packets++;
                        D(bug(" read packet pos %d\n", i));
                        uint32 size = p->length;

#if MONITOR
                        bug("Receiving Ethernet packet:\n");
                        for (int i=0; i<size; i++) {
                                bug("%02lx ", p->data[i]);
                        }
                        bug("\n");
#endif

                        // Wrap packet in message block
                        //!! maybe use esballoc()
                        mblk_t *mp;
                        if ((mp = allocb(size, 0)) != NULL) {
                                D(bug(" packet data at %p\n", mp->b_rptr));
                                memcpy(mp->b_rptr, p->data, size);
                                mp->b_wptr += size;
                                ether_packet_received(mp);
                        } else {
                                D(bug("WARNING: Cannot allocate mblk for received packet\n"));
                                num_rx_no_mem++;
                        }
                }
                p->cmd = 0;     // Free packet
                rd_pos = (rd_pos + 1) % READ_PACKET_COUNT;
                p = &net_buffer_ptr->read[rd_pos];
        }
        OTLeaveInterrupt();
}
Revision:	1.1
Committed:	2002-02-04T16:58:13Z (22 years, 5 months ago) by cebix
Branch:	MAIN
Branch point for:	cebix
Log Message:	Initial revision
#	User	Rev	Content
1	cebix	1.1	/*
2			* ether_beos.cpp - SheepShaver Ethernet Device Driver (DLPI), BeOS specific stuff
3			*
4			* SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sysdeps.h"
22			#include "ether.h"
23			#include "ether_defs.h"
24			#include "prefs.h"
25			#include "xlowmem.h"
26			#include "main.h"
27			#include "user_strings.h"
28			#include "sheep_net.h"
29
30			#define DEBUG 0
31			#include "debug.h"
32
33			#define STATISTICS 0
34			#define MONITOR 0
35
36
37			// Global variables
38			static thread_id read_thread; // Packet receiver thread
39			static bool ether_thread_active = true; // Flag for quitting the receiver thread
40
41			static area_id buffer_area; // Packet buffer area
42			static net_buffer *net_buffer_ptr; // Pointer to packet buffer
43			static sem_id read_sem, write_sem; // Semaphores to trigger packet reading/writing
44			static uint32 rd_pos; // Current read position in packet buffer
45			static uint32 wr_pos; // Current write position in packet buffer
46
47			static bool net_open = false; // Flag: initialization succeeded, network device open
48
49
50			// Prototypes
51			static status_t AO_receive_thread(void *data);
52
53
54			/*
55			* Initialize ethernet
56			*/
57
58			void EtherInit(void)
59			{
60			// Do nothing if the user disabled the network
61			if (PrefsFindBool("nonet"))
62			return;
63
64			// find net-server team
65			i_wanna_try_that_again:
66			bool found_add_on = false;
67			team_info t_info;
68			int32 t_cookie = 0;
69			image_info i_info;
70			int32 i_cookie = 0;
71			while (get_next_team_info(&t_cookie, &t_info) == B_NO_ERROR) {
72			if (strstr(t_info.args,"net_server")!=NULL) {
73			// check if sheep_net add-on is loaded
74			while (get_next_image_info(t_info.team,&i_cookie,&i_info) == B_NO_ERROR) {
75			if (strstr(i_info.name,"sheep_net")!=NULL) {
76			found_add_on = true;
77			break;
78			}
79			}
80			}
81			if (found_add_on) break;
82			}
83			if (!found_add_on) {
84
85			// Search for sheep_net in network config file
86			char str[1024];
87			bool sheep_net_found = false;
88			FILE *fin = fopen("/boot/home/config/settings/network", "r");
89			while (!feof(fin)) {
90			fgets(str, 1024, fin);
91			if (strstr(str, "PROTOCOLS"))
92			if (strstr(str, "sheep_net"))
93			sheep_net_found = true;
94			}
95			fclose(fin);
96
97			// It was found, so something else must be wrong
98			if (sheep_net_found) {
99			WarningAlert(GetString(STR_NO_NET_ADDON_WARN));
100			return;
101			}
102
103			// Not found, inform the user
104			if (!ChoiceAlert(GetString(STR_NET_CONFIG_MODIFY_WARN), GetString(STR_OK_BUTTON), GetString(STR_CANCEL_BUTTON)))
105			return;
106
107			// Change the network config file and restart the network
108			fin = fopen("/boot/home/config/settings/network", "r");
109			FILE *fout = fopen("/boot/home/config/settings/network.2", "w");
110			bool global_found = false;
111			bool modified = false;
112			while (!feof(fin)) {
113			str[0] = 0;
114			fgets(str, 1024, fin);
115			if (!global_found && strstr(str, "GLOBAL:")) {
116			global_found = true;
117			} else if (global_found && !modified && strstr(str, "PROTOCOLS")) {
118			str[strlen(str)-1] = 0;
119			strcat(str, " sheep_net\n");
120			modified = true;
121			} else if (global_found && !modified && strlen(str) > 2 && str[strlen(str) - 2] == ':') {
122			fputs("\tPROTOCOLS = sheep_net\n", fout);
123			modified = true;
124			}
125			fputs(str, fout);
126			}
127			if (!modified)
128			fputs("\tPROTOCOLS = sheep_net\n", fout);
129			fclose(fout);
130			fclose(fin);
131			remove("/boot/home/config/settings/network.orig");
132			rename("/boot/home/config/settings/network", "/boot/home/config/settings/network.orig");
133			rename("/boot/home/config/settings/network.2", "/boot/home/config/settings/network");
134
135			app_info ai;
136			if (be_roster->GetAppInfo("application/x-vnd.Be-NETS", &ai) == B_OK) {
137			BMessenger msg(NULL, ai.team);
138			if (msg.IsValid()) {
139			while (be_roster->IsRunning("application/x-vnd.Be-NETS")) {
140			msg.SendMessage(B_QUIT_REQUESTED);
141			snooze(500000);
142			}
143			}
144			}
145			BPath path;
146			find_directory(B_BEOS_BOOT_DIRECTORY, &path);
147			path.Append("Netscript");
148			char argv[3] = {"/bin/sh", (char )path.Path(), NULL};
149			thread_id net_server = load_image(2, argv, environ);
150			resume_thread(net_server);
151			status_t l;
152			wait_for_thread(net_server, &l);
153			goto i_wanna_try_that_again;
154			}
155
156			// Set up communications with add-on
157			area_id handler_buffer;
158			if ((handler_buffer = find_area("packet buffer")) < B_NO_ERROR) {
159			WarningAlert(GetString(STR_NET_ADDON_INIT_FAILED));
160			return;
161			}
162			if ((buffer_area = clone_area("local packet buffer", &net_buffer_ptr, B_ANY_ADDRESS, B_READ_AREA \| B_WRITE_AREA, handler_buffer)) < B_NO_ERROR) {
163			D(bug("EtherInit: couldn't clone packet area\n"));
164			WarningAlert(GetString(STR_NET_ADDON_CLONE_FAILED));
165			return;
166			}
167			if ((read_sem = create_sem(0, "ether read")) < B_NO_ERROR) {
168			printf("FATAL: can't create Ethernet semaphore\n");
169			return;
170			}
171			net_buffer_ptr->read_sem = read_sem;
172			write_sem = net_buffer_ptr->write_sem;
173			read_thread = spawn_thread(AO_receive_thread, "ether read", B_URGENT_DISPLAY_PRIORITY, NULL);
174			resume_thread(read_thread);
175			for (int i=0; i<WRITE_PACKET_COUNT; i++)
176			net_buffer_ptr->write[i].cmd = IN_USE \| (ACTIVATE_SHEEP_NET << 8);
177			rd_pos = wr_pos = 0;
178			release_sem(write_sem);
179
180			// Everything OK
181			net_open = true;
182			}
183
184
185			/*
186			* Exit ethernet
187			*/
188
189			void EtherExit(void)
190			{
191			if (net_open) {
192
193			// Close communications with add-on
194			for (int i=0; i<WRITE_PACKET_COUNT; i++)
195			net_buffer_ptr->write[i].cmd = IN_USE \| (DEACTIVATE_SHEEP_NET << 8);
196			release_sem(write_sem);
197
198			// Quit receiver thread
199			ether_thread_active = false;
200			status_t result;
201			release_sem(read_sem);
202			while (wait_for_thread(read_thread, &result) == B_INTERRUPTED) ;
203
204			delete_sem(read_sem);
205			delete_area(buffer_area);
206			}
207
208			#if STATISTICS
209			// Show statistics
210			printf("%ld messages put on write queue\n", num_wput);
211			printf("%ld error acks\n", num_error_acks);
212			printf("%ld packets transmitted (%ld raw, %ld normal)\n", num_tx_packets, num_tx_raw_packets, num_tx_normal_packets);
213			printf("%ld tx packets dropped because buffer full\n", num_tx_buffer_full);
214			printf("%ld packets received\n", num_rx_packets);
215			printf("%ld packets passed upstream (%ld Fast Path, %ld normal)\n", num_rx_fastpath + num_unitdata_ind, num_rx_fastpath, num_unitdata_ind);
216			printf("EtherIRQ called %ld times\n", num_ether_irq);
217			printf("%ld rx packets dropped due to low memory\n", num_rx_no_mem);
218			printf("%ld rx packets dropped because no stream found\n", num_rx_dropped);
219			printf("%ld rx packets dropped because stream not ready\n", num_rx_stream_not_ready);
220			printf("%ld rx packets dropped because no memory for unitdata_ind\n", num_rx_no_unitdata_mem);
221			#endif
222			}
223
224
225			/*
226			* Ask add-on for ethernet hardware address
227			*/
228
229			void AO_get_ethernet_address(uint8 *addr)
230			{
231			if (net_open) {
232			OTCopy48BitAddress(net_buffer_ptr->ether_addr, addr);
233			} else {
234			addr[0] = 0x12;
235			addr[1] = 0x34;
236			addr[2] = 0x56;
237			addr[3] = 0x78;
238			addr[4] = 0x9a;
239			addr[5] = 0xbc;
240			}
241			D(bug("AO_get_ethernet_address: got address %02x%02x%02x%02x%02x%02x\n", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]));
242			}
243
244
245			/*
246			* Tell add-on to enable multicast address
247			*/
248
249			void AO_enable_multicast(uint8 *addr)
250			{
251			D(bug("AO_enable_multicast\n"));
252			if (net_open) {
253			net_packet *p = &net_buffer_ptr->write[wr_pos];
254			if (p->cmd & IN_USE) {
255			D(bug("WARNING: couldn't enable multicast address\n"));
256			} else {
257			memcpy(p->data, addr, 6);
258			p->length = 6;
259			p->cmd = IN_USE \| (ADD_MULTICAST << 8);
260			wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
261			release_sem(write_sem);
262			}
263			}
264			}
265
266
267			/*
268			* Tell add-on to disable multicast address
269			*/
270
271			void AO_disable_multicast(uint8 *addr)
272			{
273			D(bug("AO_disable_multicast\n"));
274			if (net_open) {
275			net_packet *p = &net_buffer_ptr->write[wr_pos];
276			if (p->cmd & IN_USE) {
277			D(bug("WARNING: couldn't enable multicast address\n"));
278			} else {
279			memcpy(p->data, addr, 6);
280			p->length = 6;
281			p->cmd = IN_USE \| (REMOVE_MULTICAST << 8);
282			wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
283			release_sem(write_sem);
284			}
285			D(bug("WARNING: couldn't disable multicast address\n"));
286			}
287			}
288
289
290			/*
291			* Tell add-on to transmit one packet
292			*/
293
294			void AO_transmit_packet(mblk_t *mp)
295			{
296			D(bug("AO_transmit_packet\n"));
297			if (net_open) {
298			net_packet *p = &net_buffer_ptr->write[wr_pos];
299			if (p->cmd & IN_USE) {
300			D(bug("WARNING: couldn't transmit packet (buffer full)\n"));
301			num_tx_buffer_full++;
302			} else {
303			D(bug(" write packet pos %d\n", i));
304			num_tx_packets++;
305
306			// Copy packet to buffer
307			uint8 *start;
308			uint8 *bp = start = p->data;
309			while (mp) {
310			uint32 size = mp->b_wptr - mp->b_rptr;
311			memcpy(bp, mp->b_rptr, size);
312			bp += size;
313			mp = mp->b_cont;
314			}
315
316			#if MONITOR
317			bug("Sending Ethernet packet:\n");
318			for (int i=0; i<(uint32)(bp - start); i++) {
319			bug("%02lx ", start[i]);
320			}
321			bug("\n");
322			#endif
323
324			// Notify add-on
325			p->length = (uint32)(bp - start);
326			p->cmd = IN_USE \| (SHEEP_PACKET << 8);
327			wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
328			release_sem(write_sem);
329			}
330			}
331			}
332
333
334			/*
335			* Packet reception thread
336			*/
337
338			static status_t AO_receive_thread(void *data)
339			{
340			while (ether_thread_active) {
341			if (net_buffer_ptr->read[rd_pos].cmd & IN_USE) {
342			if (ether_driver_opened) {
343			D(bug(" packet received, triggering Ethernet interrupt\n"));
344			SetInterruptFlag(INTFLAG_ETHER);
345			TriggerInterrupt();
346			}
347			}
348			acquire_sem_etc(read_sem, 1, B_TIMEOUT, 25000);
349			}
350			return 0;
351			}
352
353
354			/*
355			* Ethernet interrupt
356			*/
357
358			void EtherIRQ(void)
359			{
360			D(bug("EtherIRQ\n"));
361			num_ether_irq++;
362			OTEnterInterrupt();
363
364			// Send received packets to OpenTransport
365			net_packet *p = &net_buffer_ptr->read[rd_pos];
366			while (p->cmd & IN_USE) {
367			if ((p->cmd >> 8) == SHEEP_PACKET) {
368			num_rx_packets++;
369			D(bug(" read packet pos %d\n", i));
370			uint32 size = p->length;
371
372			#if MONITOR
373			bug("Receiving Ethernet packet:\n");
374			for (int i=0; i<size; i++) {
375			bug("%02lx ", p->data[i]);
376			}
377			bug("\n");
378			#endif
379
380			// Wrap packet in message block
381			//!! maybe use esballoc()
382			mblk_t *mp;
383			if ((mp = allocb(size, 0)) != NULL) {
384			D(bug(" packet data at %p\n", mp->b_rptr));
385			memcpy(mp->b_rptr, p->data, size);
386			mp->b_wptr += size;
387			ether_packet_received(mp);
388			} else {
389			D(bug("WARNING: Cannot allocate mblk for received packet\n"));
390			num_rx_no_mem++;
391			}
392			}
393			p->cmd = 0; // Free packet
394			rd_pos = (rd_pos + 1) % READ_PACKET_COUNT;
395			p = &net_buffer_ptr->read[rd_pos];
396			}
397			OTLeaveInterrupt();
398			}