Skip to content

Commit a7a9ab4

Browse files
committed
net_plip: More cleanups + static buffers for transmit/receive instead of heap thrashing
1 parent 9e8acc0 commit a7a9ab4

1 file changed

Lines changed: 54 additions & 75 deletions

File tree

‎src/network/net_plip.c‎

Lines changed: 54 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -55,26 +55,26 @@ enum {
5555
};
5656

5757
typedef struct plip_t {
58-
uint8_t mac[6];
59-
6058
void *lpt;
59+
netcard_t *card;
60+
uint8_t mac[6];
61+
uint8_t status;
62+
uint8_t state;
63+
64+
uint8_t rx_checksum;
65+
uint8_t rx_return_state;
66+
uint16_t rx_len;
67+
uint16_t rx_ptr;
68+
uint8_t tx_checksum;
69+
uint8_t tx_checksum_calc;
70+
uint16_t tx_len;
71+
uint16_t tx_ptr;
72+
6173
pc_timer_t rx_timer;
6274
pc_timer_t timeout_timer;
63-
uint8_t status;
6475

65-
uint8_t state;
66-
uint8_t tx_checksum;
67-
uint8_t tx_checksum_calc;
68-
uint8_t *tx_pkt;
69-
uint16_t tx_len;
70-
uint16_t tx_ptr;
71-
72-
uint8_t *rx_pkt;
73-
uint8_t rx_checksum;
74-
uint8_t rx_return_state;
75-
uint16_t rx_len;
76-
uint16_t rx_ptr;
77-
netcard_t *card;
76+
uint8_t rx_pkt[NET_MAX_FRAME];
77+
uint8_t tx_pkt[NET_MAX_FRAME];
7878
} plip_t;
7979

8080
#ifdef ENABLE_PLIP_LOG
@@ -100,20 +100,11 @@ timeout_timer(void *priv)
100100
{
101101
plip_t *dev = (plip_t *) priv;
102102

103-
plip_log(1, "PLIP: timeout at state %d status %02X\n", dev->state, dev->status);
103+
plip_log(1, "PLIP: Timeout at state %02X status %02X\n", dev->state, dev->status);
104104

105105
/* Throw everything out the window. */
106106
dev->state = PLIP_START;
107-
dev->status = 0x80;
108-
109-
if (dev->tx_pkt) {
110-
free(dev->tx_pkt);
111-
dev->tx_pkt = NULL;
112-
}
113-
if (dev->rx_pkt) {
114-
free(dev->rx_pkt);
115-
dev->rx_pkt = NULL;
116-
}
107+
dev->status = 0x80; /* nBusy */
117108

118109
timer_disable(&dev->timeout_timer);
119110
}
@@ -128,7 +119,7 @@ plip_write_data(uint8_t val, void *priv)
128119
switch (dev->state) {
129120
case PLIP_START:
130121
if (val & 0x08) { /* D3==nAck wakes us up */
131-
plip_log(2, "PLIP: ACK wakeup\n");
122+
plip_log(2, "PLIP: nAck wakeup\n");
132123
dev->state = PLIP_TX_LEN_LSB_LOW;
133124
dev->status = 0x08; /* nFault */
134125
break;
@@ -139,7 +130,6 @@ plip_write_data(uint8_t val, void *priv)
139130
if (!(val & 0x10))
140131
return; /* D4==!nBusy not asserted yet */
141132
dev->tx_len = val & 0xf;
142-
plip_log(2, "PLIP: tx_len = %04X (1/4)\n", dev->tx_len);
143133
dev->state = PLIP_TX_LEN_LSB_HIGH;
144134
dev->status &= ~0x88; /* clear nFault|nBusy */
145135
break;
@@ -148,7 +138,6 @@ plip_write_data(uint8_t val, void *priv)
148138
if (val & 0x10)
149139
return; /* !D4==nBusy not asserted yet */
150140
dev->tx_len |= (val & 0xf) << 4;
151-
plip_log(2, "PLIP: tx_len = %04X (2/4)\n", dev->tx_len);
152141
dev->state = PLIP_TX_LEN_MSB_LOW;
153142
dev->status |= 0x80; /* toggling nBusy from now on */
154143
break;
@@ -157,7 +146,6 @@ plip_write_data(uint8_t val, void *priv)
157146
if (!(val & 0x10))
158147
return; /* D4==!nBusy not asserted yet */
159148
dev->tx_len |= (val & 0xf) << 8;
160-
plip_log(2, "PLIP: tx_len = %04X (3/4)\n", dev->tx_len);
161149
dev->state = PLIP_TX_LEN_MSB_HIGH;
162150
dev->status &= ~0x80;
163151
break;
@@ -166,11 +154,9 @@ plip_write_data(uint8_t val, void *priv)
166154
if (val & 0x10)
167155
return; /* !D4==nBusy not asserted yet */
168156
dev->tx_len |= (val & 0xf) << 12;
169-
plip_log(2, "PLIP: tx_len = %04X (4/4)\n", dev->tx_len);
157+
plip_log(2, "PLIP: tx_len = %04X\n", dev->tx_len);
170158

171-
/* We have the length, allocate a packet. */
172-
if (UNLIKELY(!(dev->tx_pkt = calloc(1, dev->tx_len))))
173-
fatal("PLIP: unable to allocate tx_pkt\n");
159+
/* Begin transmitting data. */
174160
dev->tx_ptr = 0;
175161
dev->tx_checksum_calc = 0;
176162

@@ -181,18 +167,23 @@ plip_write_data(uint8_t val, void *priv)
181167
case PLIP_TX_DATA_LOW:
182168
if (!(val & 0x10))
183169
return; /* D4==!nBusy not asserted yet */
184-
dev->tx_pkt[dev->tx_ptr] = val & 0x0f;
185-
plip_log(2, "PLIP: tx_pkt[%d] = %02X (1/2)\n", dev->tx_ptr, dev->tx_pkt[dev->tx_ptr]);
170+
if (LIKELY(dev->tx_ptr) < sizeof(dev->tx_pkt))
171+
dev->tx_pkt[dev->tx_ptr] = val & 0x0f;
186172
dev->state = PLIP_TX_DATA_HIGH;
187173
dev->status &= ~0x80;
188174
break;
189175

190176
case PLIP_TX_DATA_HIGH:
191177
if (val & 0x10)
192178
return; /* !D4==nBusy not asserted yet */
193-
dev->tx_pkt[dev->tx_ptr] |= (val & 0x0f) << 4;
194-
plip_log(2, "PLIP: tx_pkt[%d] = %02X (2/2)\n", dev->tx_ptr, dev->tx_pkt[dev->tx_ptr]);
195-
dev->tx_checksum_calc += dev->tx_pkt[dev->tx_ptr++];
179+
if (LIKELY(dev->tx_ptr) < sizeof(dev->tx_pkt)) {
180+
dev->tx_pkt[dev->tx_ptr] |= val << 4;
181+
dev->tx_checksum_calc += dev->tx_pkt[dev->tx_ptr];
182+
plip_log(2, "PLIP: tx_pkt[%d] = %02X\n", dev->tx_ptr, dev->tx_pkt[dev->tx_ptr]);
183+
} else {
184+
plip_log(2, "PLIP: tx_pkt[%d] = overflow\n", dev->tx_ptr);
185+
}
186+
dev->tx_ptr++;
196187

197188
/* Are we done yet? */
198189
if (dev->tx_ptr < dev->tx_len) /* no, receive another byte */
@@ -206,7 +197,6 @@ plip_write_data(uint8_t val, void *priv)
206197
if (!(val & 0x10))
207198
return; /* D4==!nBusy not asserted yet */
208199
dev->tx_checksum = val & 0x0f;
209-
plip_log(2, "PLIP: tx_checksum = %02X (1/2)\n", dev->tx_checksum);
210200
dev->state = PLIP_TX_CHECKSUM_HIGH;
211201
dev->status &= ~0x80;
212202
break;
@@ -215,23 +205,21 @@ plip_write_data(uint8_t val, void *priv)
215205
if (val & 0x10)
216206
return; /* !D4==nBusy not asserted yet */
217207
dev->tx_checksum |= (val & 0x0f) << 4;
218-
plip_log(2, "PLIP: tx_checksum = %02X (2/2)\n", dev->tx_checksum);
208+
plip_log(2, "PLIP: tx_checksum = %02X\n", dev->tx_checksum);
219209

220210
/* Verify checksum. */
221211
if (dev->tx_checksum_calc == dev->tx_checksum) {
222212
/* Make sure we know the other end's MAC address. */
223213
memcpy(dev->mac, dev->tx_pkt + 6, 6);
224214

225215
/* Transmit packet. */
226-
plip_log(2, "PLIP: transmitting %d-byte packet\n", dev->tx_len);
216+
plip_log(1, "PLIP: Transmitting %d-byte packet\n", dev->tx_len);
227217
network_tx(dev->card, dev->tx_pkt, dev->tx_len);
228218
} else {
229-
plip_log(1, "PLIP: checksum error: expected %02X, got %02X\n", dev->tx_checksum_calc, dev->tx_checksum);
219+
plip_log(1, "PLIP: Transmit checksum error, expected %02X got %02X\n", dev->tx_checksum_calc, dev->tx_checksum);
230220
}
231221

232222
/* We're done with this packet. */
233-
free(dev->tx_pkt);
234-
dev->tx_pkt = NULL;
235223
dev->tx_len = 0;
236224

237225
dev->state = PLIP_END;
@@ -241,15 +229,13 @@ plip_write_data(uint8_t val, void *priv)
241229
case PLIP_RX_LEN_LSB_LOW:
242230
if (!(val & 0x01))
243231
return; /* D0==nFault not asserted yet */
244-
plip_log(2, "PLIP: rx_len = %04X (1/4)\n", dev->rx_len);
245232
dev->status = (dev->rx_len & 0x0f) << 3;
246233
dev->state = PLIP_RX_LEN_LSB_HIGH;
247234
break;
248235

249236
case PLIP_RX_LEN_LSB_HIGH:
250237
if (!(val & 0x10))
251238
return; /* D4==!nBusy not asserted yet */
252-
plip_log(2, "PLIP: rx_len = %04X (2/4)\n", dev->rx_len);
253239
dev->status = ((dev->rx_len >> 4) & 0x0f) << 3;
254240
dev->status |= 0x80;
255241
dev->state = PLIP_RX_LEN_MSB_LOW;
@@ -258,18 +244,18 @@ plip_write_data(uint8_t val, void *priv)
258244
case PLIP_RX_LEN_MSB_LOW:
259245
if (val & 0x10)
260246
return; /* !D4==nBusy not asserted yet */
261-
plip_log(2, "PLIP: rx_len = %04X (3/4)\n", dev->rx_len);
262247
dev->status = ((dev->rx_len >> 8) & 0x0f) << 3;
263248
dev->state = PLIP_RX_LEN_MSB_HIGH;
264249
break;
265250

266251
case PLIP_RX_LEN_MSB_HIGH:
267252
if (!(val & 0x10))
268253
return; /* D4==!nBusy not asserted yet */
269-
plip_log(2, "PLIP: rx_len = %04X (4/4)\n", dev->rx_len);
254+
plip_log(2, "PLIP: rx_len = %04X\n", dev->rx_len);
270255
dev->status = ((dev->rx_len >> 12) & 0x0f) << 3;
271256
dev->status |= 0x80;
272257

258+
/* Begin receiving data. */
273259
dev->rx_ptr = 0;
274260
dev->rx_checksum = 0;
275261
dev->state = PLIP_RX_DATA_LOW;
@@ -278,15 +264,14 @@ plip_write_data(uint8_t val, void *priv)
278264
case PLIP_RX_DATA_LOW:
279265
if (val & 0x10)
280266
return; /* !D4==nBusy not asserted yet */
281-
plip_log(2, "PLIP: rx_pkt[%d] = %02X (1/2)\n", dev->rx_ptr, dev->rx_pkt[dev->rx_ptr]);
282267
dev->status = (dev->rx_pkt[dev->rx_ptr] & 0x0f) << 3;
283268
dev->state = PLIP_RX_DATA_HIGH;
284269
break;
285270

286271
case PLIP_RX_DATA_HIGH:
287272
if (!(val & 0x10))
288273
return; /* D4==!nBusy not asserted yet */
289-
plip_log(2, "PLIP: rx_pkt[%d] = %02X (2/2)\n", dev->rx_ptr, dev->rx_pkt[dev->rx_ptr]);
274+
plip_log(2, "PLIP: rx_pkt[%d] = %02X\n", dev->rx_ptr, dev->rx_pkt[dev->rx_ptr]);
290275
dev->status = ((dev->rx_pkt[dev->rx_ptr] >> 4) & 0x0f) << 3;
291276
dev->status |= 0x80;
292277
dev->rx_checksum += dev->rx_pkt[dev->rx_ptr++];
@@ -301,29 +286,26 @@ plip_write_data(uint8_t val, void *priv)
301286
case PLIP_RX_CHECKSUM_LOW:
302287
if (val & 0x10)
303288
return; /* !D4==nBusy not asserted yet */
304-
plip_log(2, "PLIP: rx_checksum = %02X (1/2)\n", dev->rx_checksum);
305289
dev->status = (dev->rx_checksum & 0x0f) << 3;
306290
dev->state = PLIP_RX_CHECKSUM_HIGH;
307291
break;
308292

309293
case PLIP_RX_CHECKSUM_HIGH:
310294
if (!(val & 0x10))
311295
return; /* D4==!nBusy not asserted yet */
312-
plip_log(2, "PLIP: rx_checksum = %02X (2/2)\n", dev->rx_checksum);
296+
plip_log(2, "PLIP: rx_checksum = %02X\n", dev->rx_checksum);
313297
dev->status = ((dev->rx_checksum >> 4) & 0x0f) << 3;
314298
dev->status |= 0x80;
315299

316300
/* We're done with this packet. */
317-
free(dev->rx_pkt);
318-
dev->rx_pkt = NULL;
319301
dev->rx_len = 0;
320302

321303
dev->state = PLIP_END;
322304
break;
323305

324306
case PLIP_END:
325307
if (val == 0x00) { /* written after TX or RX is done */
326-
plip_log(2, "PLIP: end\n");
308+
plip_log(2, "PLIP: End of packet\n");
327309
dev->status = 0x80; /* nBusy */
328310
dev->state = PLIP_START;
329311

@@ -366,26 +348,26 @@ plip_read_status(void *priv)
366348
static void
367349
plip_receive_packet(plip_t *dev)
368350
{
369-
/* At least the Linux driver supports being interrupted
370-
in the PLIP_TX_LEN_LSB_LOW state, but let's be safe. */
371-
if (dev->state > PLIP_START) {
372-
plip_log(3, "PLIP: cannot receive, operation already in progress\n");
351+
/* Stop if we have nothing to receive. */
352+
if (!dev->rx_len)
373353
return;
374-
}
375354

376-
if (!dev->rx_pkt || !dev->rx_len) /* unpause RX queue if there's no packet to receive */
355+
/* Stop if we're already transmitting or receiving. */
356+
if (dev->state > PLIP_START) {
357+
plip_log(2, "PLIP: Cannot receive, operation already in progress\n");
377358
return;
359+
}
378360

379-
plip_log(2, "PLIP: receiving %d-byte packet\n", dev->rx_len);
361+
plip_log(1, "PLIP: Receiving %d-byte packet\n", dev->rx_len);
380362

381363
/* Set up to receive a packet. */
382-
dev->status = 0xc7; /* Linux expects dsr == nBusy|nAck, DOS expects that and reserved[2:0] */
364+
dev->status = 0xc7; /* Linux expects nBusy|nAck|!PError|!Select|!nFault, DOS also |reserved[2:0] */
383365
dev->state = PLIP_RX_LEN_LSB_LOW;
384366

385367
/* Engage timeout timer. */
386368
timer_set_delay_u64(&dev->timeout_timer, 1000000 * TIMER_USEC);
387369

388-
/* Wake the other end up. */
370+
/* Wake the guest driver up. */
389371
if (dev->lpt)
390372
lpt_irq(dev->lpt, 1);
391373
}
@@ -407,21 +389,18 @@ plip_rx(void *priv, uint8_t *buf, int io_len)
407389
{
408390
plip_t *dev = (plip_t *) priv;
409391

410-
plip_log(2, "PLIP: incoming %d-byte packet\n", io_len);
411-
412-
if (dev->rx_pkt) { /* shouldn't really happen with the RX queue paused */
413-
plip_log(3, "PLIP: already have a packet to receive");
392+
if (dev->rx_len) {
393+
plip_log(2, "PLIP: Incoming %d-byte packet declined\n", io_len);
414394
return 0;
415395
}
416396

417-
if (UNLIKELY(!(dev->rx_pkt = calloc(1, io_len))))
418-
fatal("PLIP: unable to allocate rx_pkt\n");
397+
plip_log(2, "PLIP: Incoming %d-byte packet accepted\n", io_len);
419398

420399
/* Copy this packet to our buffer. */
421-
dev->rx_len = io_len;
400+
dev->rx_len = MIN(io_len, sizeof(dev->rx_pkt));
422401
memcpy(dev->rx_pkt, buf, dev->rx_len);
423402

424-
/* Dispatch this packet immediately if we're doing nothing. */
403+
/* Start receiving this packet immediately if we're doing nothing. */
425404
plip_receive_packet(dev);
426405

427406
return 1;
@@ -439,7 +418,7 @@ plip_init(const device_t *info)
439418

440419
memset(dev->mac, 0xfc, 6); /* static MAC used by Linux; just a placeholder */
441420

442-
dev->status = 0x80;
421+
dev->status = 0x80; /* nBusy */
443422

444423
timer_add(&dev->rx_timer, rx_timer, dev, 0);
445424
timer_add(&dev->timeout_timer, timeout_timer, dev, 0);

0 commit comments

Comments
 (0)