/[dynamips]/upstream/dynamips-0.2.5/dev_c3600.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /upstream/dynamips-0.2.5/dev_c3600.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (show annotations)
Sat Oct 6 16:01:44 2007 UTC (12 years, 2 months ago) by dpavlin
File MIME type: text/plain
File size: 40394 byte(s)
import 0.2.5 from upstream

1 /*
2 * Cisco 3600 simulation platform.
3 * Copyright (c) 2006 Christophe Fillot (cf@utc.fr)
4 *
5 * Generic Cisco 3600 routines and definitions (EEPROM,...).
6 */
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <unistd.h>
12 #include <sys/types.h>
13 #include <assert.h>
14
15 #include "mips64.h"
16 #include "dynamips.h"
17 #include "memory.h"
18 #include "device.h"
19 #include "pci_io.h"
20 #include "cisco_eeprom.h"
21 #include "dev_c3600.h"
22 #include "dev_c3600_bay.h"
23 #include "dev_vtty.h"
24 #include "registry.h"
25
26 /* ======================================================================== */
27 /* EEPROM definitions */
28 /* ======================================================================== */
29
30 /* Cisco 3620 mainboard EEPROM */
31 static m_uint16_t eeprom_c3620_mainboard[64] = {
32 0x0001, 0x0000, 0x0000, 0x0000, 0x0AFF, 0x7318, 0x5011, 0x0020,
33 0x0000, 0x0000, 0xA0FF, 0x9904, 0x19FF, 0xFFFF, 0xFFFF, 0x0002,
34 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
35 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
36 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
37 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
38 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
39 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
40 };
41
42 /* Cisco 3640 mainboard EEPROM */
43 static m_uint16_t eeprom_c3640_mainboard[64] = {
44 0x0001, 0x0000, 0x0000, 0x0000, 0x0AFF, 0x7316, 0x8514, 0x0040,
45 0x0000, 0x0000, 0xA1FF, 0x0102, 0x22FF, 0xFFFF, 0xFFFF, 0x0002,
46 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
47 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
48 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
49 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
50 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
51 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
52 };
53
54 /* Cisco 3660 backplane EEPROM */
55 static m_uint16_t eeprom_c3660_backplane[64] = {
56 0x04FF, 0x4000, 0xC841, 0x0100, 0xC046, 0x0320, 0x0012, 0x8402,
57 0x4243, 0x3080, 0x0000, 0x0000, 0x0202, 0xC18B, 0x4841, 0x4430,
58 0x3434, 0x3431, 0x3135, 0x4A03, 0x0081, 0x0000, 0x0000, 0x0400,
59 0xC28B, 0x4A41, 0x4230, 0x3434, 0x3643, 0x304C, 0x32C3, 0x0600,
60 0x044D, 0x0EC2, 0xD043, 0x0070, 0xC408, 0x0000, 0x0000, 0x0000,
61 0x0000, 0x851C, 0x0A5B, 0x0201, 0x06FF, 0xFFFF, 0xFFFF, 0xFFFF,
62 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
63 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
64 };
65
66 /* ======================================================================== */
67 /* Chassis Drivers */
68 /* ======================================================================== */
69 static int c3620_init(c3600_t *router);
70 static int c3640_init(c3600_t *router);
71 static int c3660_init(c3600_t *router);
72
73 static struct c3600_chassis_driver chassis_drivers[] = {
74 { "3620" , 3620, 1, c3620_init,
75 eeprom_c3620_mainboard, sizeof(eeprom_c3620_mainboard)/2 },
76 { "3640" , 3640, 1, c3640_init,
77 eeprom_c3640_mainboard, sizeof(eeprom_c3640_mainboard)/2 },
78 { "3660" , 3660, 1, c3660_init,
79 eeprom_c3660_backplane, sizeof(eeprom_c3660_backplane)/2 },
80
81 { NULL , -1, 0, NULL },
82 };
83
84 /* ======================================================================== */
85 /* Network Module Drivers */
86 /* ======================================================================== */
87 static struct c3600_nm_driver *nm_drivers[] = {
88 &dev_c3600_nm_1e_driver,
89 &dev_c3600_nm_4e_driver,
90 &dev_c3600_nm_1fe_tx_driver,
91 &dev_c3600_nm_4t_driver,
92 &dev_c3600_leopard_2fe_driver,
93 NULL,
94 };
95
96 /* ======================================================================== */
97 /* Cisco 3600 router instances */
98 /* ======================================================================== */
99
100 /* Directly extract the configuration from the NVRAM device */
101 ssize_t c3600_nvram_extract_config(vm_instance_t *vm,char **buffer)
102 {
103 struct vdevice *nvram_dev;
104 m_uint32_t start,end,clen,nvlen;
105 m_uint16_t magic1,magic2;
106 m_uint64_t addr;
107
108 if (!(nvram_dev = dev_get_by_name(vm,"nvram")))
109 return(-1);
110
111 addr = nvram_dev->phys_addr + vm->nvram_rom_space;
112 magic1 = physmem_copy_u16_from_vm(vm,addr+0x06);
113 magic2 = physmem_copy_u16_from_vm(vm,addr+0x08);
114
115 if ((magic1 != 0xF0A5) || (magic2 != 0xABCD)) {
116 vm_error(vm,"unable to find IOS magic numbers (0x%x,0x%x)!\n",
117 magic1,magic2);
118 return(-1);
119 }
120
121 start = physmem_copy_u32_from_vm(vm,addr+0x10) + 1;
122 end = physmem_copy_u32_from_vm(vm,addr+0x14);
123 nvlen = physmem_copy_u32_from_vm(vm,addr+0x18);
124 clen = end - start;
125
126 if ((clen + 1) != nvlen) {
127 vm_error(vm,"invalid configuration size (0x%x)\n",nvlen);
128 return(-1);
129 }
130
131 if (!(*buffer = malloc(clen+1))) {
132 vm_error(vm,"unable to allocate config buffer (%u bytes)\n",clen);
133 return(-1);
134 }
135
136 physmem_copy_from_vm(vm,*buffer,addr+start+0x08,clen);
137 (*buffer)[clen] = 0;
138 return(clen);
139 }
140
141 /* Compute NVRAM checksum */
142 static u_int16_t nvram_cksum(vm_instance_t *vm,m_uint64_t addr,size_t count)
143 {
144 m_uint32_t sum = 0;
145
146 while(count > 1) {
147 sum = sum + physmem_copy_u16_from_vm(vm,addr);
148 addr += sizeof(m_uint16_t);
149 count -= sizeof(m_uint16_t);
150 }
151
152 if (count > 0)
153 sum = sum + ((physmem_copy_u16_from_vm(vm,addr) & 0xFF) << 8);
154
155 while(sum>>16)
156 sum = (sum & 0xffff) + (sum >> 16);
157
158 return(~sum);
159 }
160
161
162 /* Directly push the IOS configuration to the NVRAM device */
163 int c3600_nvram_push_config(vm_instance_t *vm,char *buffer,size_t len)
164 {
165 struct vdevice *nvram_dev;
166 m_uint64_t addr,cfg_addr;
167 m_uint32_t tmp,cfg_offset;
168 m_uint32_t cklen;
169 m_uint16_t cksum;
170
171 if (!(nvram_dev = dev_get_by_name(vm,"nvram")))
172 return(-1);
173
174 addr = nvram_dev->phys_addr + vm->nvram_rom_space;
175 cfg_offset = 0x2c;
176 cfg_addr = addr + cfg_offset;;
177
178 /* Write IOS tag, uncompressed config... */
179 physmem_copy_u16_to_vm(vm,addr+0x06,0xF0A5);
180 physmem_copy_u16_to_vm(vm,addr+0x08,0xABCD); /* Magic number */
181 physmem_copy_u16_to_vm(vm,addr+0x0a,0x0001); /* ??? */
182 physmem_copy_u16_to_vm(vm,addr+0x0c,0x0000); /* Checksum */
183 physmem_copy_u16_to_vm(vm,addr+0x0e,0x0c04); /* IOS version */
184
185 /* Store file contents to NVRAM */
186 physmem_copy_to_vm(vm,buffer,cfg_addr,len);
187
188 /* Write config addresses + size */
189 tmp = cfg_addr - addr - 0x08;
190
191 physmem_copy_u32_to_vm(vm,addr+0x10,tmp);
192 physmem_copy_u32_to_vm(vm,addr+0x14,tmp + len);
193 physmem_copy_u32_to_vm(vm,addr+0x18,len);
194
195 /* Compute the checksum */
196 cklen = nvram_dev->phys_len - (vm->nvram_rom_space + 0x08);
197 cksum = nvram_cksum(vm,addr+0x08,cklen);
198 physmem_copy_u16_to_vm(vm,addr+0x0c,cksum);
199 return(0);
200 }
201
202 /* Create a new router instance */
203 c3600_t *c3600_create_instance(char *name,int instance_id)
204 {
205 c3600_t *router;
206
207 if (!(router = malloc(sizeof(*router)))) {
208 fprintf(stderr,"C3600 '%s': Unable to create new instance!\n",name);
209 return NULL;
210 }
211
212 memset(router,0,sizeof(*router));
213
214 if (!(router->vm = vm_create(name,instance_id,VM_TYPE_C3600))) {
215 fprintf(stderr,"C3600 '%s': unable to create VM instance!\n",name);
216 goto err_vm;
217 }
218
219 c3600_init_defaults(router);
220 router->vm->hw_data = router;
221 return router;
222
223 err_vm:
224 free(router);
225 return NULL;
226 }
227
228 /* Free resources used by a router instance */
229 static int c3600_free_instance(void *data,void *arg)
230 {
231 vm_instance_t *vm = data;
232 c3600_t *router;
233 int i;
234
235 if (vm->type == VM_TYPE_C3600) {
236 router = VM_C3600(vm);
237
238 /* Stop all CPUs */
239 if (vm->cpu_group != NULL) {
240 vm_stop(vm);
241
242 if (cpu_group_sync_state(vm->cpu_group) == -1) {
243 vm_error(vm,"unable to sync with system CPUs.\n");
244 return(FALSE);
245 }
246 }
247
248 /* Remove NIO bindings */
249 for(i=0;i<C3600_MAX_NM_BAYS;i++)
250 c3600_nm_remove_all_nio_bindings(router,i);
251
252 /* Shutdown all Network Modules */
253 c3600_nm_shutdown_all(router);
254
255 /* Free all resources used by VM */
256 vm_free(vm);
257
258 /* Free the router structure */
259 free(router);
260 return(TRUE);
261 }
262
263 return(FALSE);
264 }
265
266 /* Delete a router instance */
267 int c3600_delete_instance(char *name)
268 {
269 return(registry_delete_if_unused(name,OBJ_TYPE_VM,
270 c3600_free_instance,NULL));
271 }
272
273 /* Delete all router instances */
274 int c3600_delete_all_instances(void)
275 {
276 return(registry_delete_type(OBJ_TYPE_VM,c3600_free_instance,NULL));
277 }
278
279 /* Save configuration of a C3600 instance */
280 void c3600_save_config(c3600_t *router,FILE *fd)
281 {
282 vm_instance_t *vm = router->vm;
283 struct c3600_nio_binding *nb;
284 struct c3600_nm_bay *bay;
285 int i;
286
287 /* General settings */
288 fprintf(fd,"c3600 create %s %u\n",vm->name,vm->instance_id);
289
290 fprintf(fd,"c3600 set_chassis %s %s\n",
291 vm->name,router->chassis_driver->chassis_type);
292
293 /* VM configuration */
294 vm_save_config(vm,fd);
295
296 /* Network Module settings */
297 for(i=0;i<C3600_MAX_NM_BAYS;i++) {
298 if (!(bay = c3600_nm_get_info(router,i)))
299 continue;
300
301 if (bay->dev_type) {
302 fprintf(fd,"c3600 add_nm_binding %s %u %s\n",
303 vm->name,i,bay->dev_type);
304 }
305
306 for(nb=bay->nio_list;nb;nb=nb->next) {
307 fprintf(fd,"c3600 add_nio_binding %s %u %u %s\n",
308 vm->name,i,nb->port_id,nb->nio->name);
309 }
310 }
311
312 fprintf(fd,"\n");
313 }
314
315 /* Save configurations of all C3600 instances */
316 static void c3600_reg_save_config(registry_entry_t *entry,void *opt,int *err)
317 {
318 vm_instance_t *vm = entry->data;
319 c3600_t *router = VM_C3600(vm);
320
321 if (vm->type == VM_TYPE_C3600)
322 c3600_save_config(router,(FILE *)opt);
323 }
324
325 void c3600_save_config_all(FILE *fd)
326 {
327 registry_foreach_type(OBJ_TYPE_VM,c3600_reg_save_config,fd,NULL);
328 }
329
330 /* Set NM EEPROM definition */
331 int c3600_nm_set_eeprom(c3600_t *router,u_int nm_bay,
332 const struct c3600_eeprom *eeprom)
333 {
334 if (nm_bay >= C3600_MAX_NM_BAYS) {
335 vm_error(router->vm,"c3600_nm_set_eeprom: invalid NM Bay %u.\n",nm_bay);
336 return(-1);
337 }
338
339 /* 3620/3640 */
340 router->nm_bay[nm_bay].eeprom_data = eeprom->data;
341 router->nm_bay[nm_bay].eeprom_data_len = eeprom->len;
342
343 /* 3660 */
344 router->c3660_nm_eeprom_def[nm_bay].data = eeprom->data;
345 router->c3660_nm_eeprom_def[nm_bay].data_len = eeprom->len;
346 return(0);
347 }
348
349 /* Unset NM EEPROM definition (empty bay) */
350 int c3600_nm_unset_eeprom(c3600_t *router,u_int nm_bay)
351 {
352 if (nm_bay >= C3600_MAX_NM_BAYS) {
353 vm_error(router->vm,"c3600_nm_set_eeprom: invalid NM Bay %u.\n",nm_bay);
354 return(-1);
355 }
356
357 /* 3620/3640 */
358 router->nm_bay[nm_bay].eeprom_data = NULL;
359 router->nm_bay[nm_bay].eeprom_data_len = 0;
360
361 /* 3660 */
362 router->c3660_nm_eeprom_def[nm_bay].data = NULL;
363 router->c3660_nm_eeprom_def[nm_bay].data_len = 0;
364 return(0);
365 }
366
367 /* Check if a bay has a port adapter */
368 int c3600_nm_check_eeprom(c3600_t *router,u_int nm_bay)
369 {
370 if (nm_bay >= C3600_MAX_NM_BAYS)
371 return(FALSE);
372
373 return((router->nm_bay[nm_bay].eeprom_data != NULL) ? TRUE : FALSE);
374 }
375
376 /* Get bay info */
377 struct c3600_nm_bay *c3600_nm_get_info(c3600_t *router,u_int nm_bay)
378 {
379 if (nm_bay >= C3600_MAX_NM_BAYS)
380 return NULL;
381
382 return(&router->nm_bay[nm_bay]);
383 }
384
385 /* Get NM type */
386 char *c3600_nm_get_type(c3600_t *router,u_int nm_bay)
387 {
388 struct c3600_nm_bay *bay;
389
390 bay = c3600_nm_get_info(router,nm_bay);
391 return((bay != NULL) ? bay->dev_type : NULL);
392 }
393
394 /* Get driver info about the specified slot */
395 void *c3600_nm_get_drvinfo(c3600_t *router,u_int nm_bay)
396 {
397 struct c3600_nm_bay *bay;
398
399 bay = c3600_nm_get_info(router,nm_bay);
400 return((bay != NULL) ? bay->drv_info : NULL);
401 }
402
403 /* Set driver info for the specified slot */
404 int c3600_nm_set_drvinfo(c3600_t *router,u_int nm_bay,void *drv_info)
405 {
406 struct c3600_nm_bay *bay;
407
408 if (!(bay = c3600_nm_get_info(router,nm_bay)))
409 return(-1);
410
411 bay->drv_info = drv_info;
412 return(0);
413 }
414
415 /* Get a NM driver */
416 static struct c3600_nm_driver *c3600_nm_get_driver(char *dev_type)
417 {
418 int i;
419
420 for(i=0;nm_drivers[i];i++)
421 if (!strcmp(nm_drivers[i]->dev_type,dev_type))
422 return nm_drivers[i];
423
424 return NULL;
425 }
426
427 /* Add a NM binding */
428 int c3600_nm_add_binding(c3600_t *router,char *dev_type,u_int nm_bay)
429 {
430 struct c3600_nm_driver *nm_driver;
431 struct c3600_nm_bay *bay;
432
433 if (!(bay = c3600_nm_get_info(router,nm_bay)))
434 return(-1);
435
436 /* check that this bay is empty */
437 if (bay->dev_type != NULL) {
438 vm_error(router->vm,"a NM already exists in slot %u.\n",nm_bay);
439 return(-1);
440 }
441
442 /* find the NM driver */
443 if (!(nm_driver = c3600_nm_get_driver(dev_type))) {
444 vm_error(router->vm,"unknown NM type '%s'.\n",dev_type);
445 return(-1);
446 }
447
448 bay->dev_type = nm_driver->dev_type;
449 bay->nm_driver = nm_driver;
450 return(0);
451 }
452
453 /* Remove a NM binding */
454 int c3600_nm_remove_binding(c3600_t *router,u_int nm_bay)
455 {
456 struct c3600_nm_bay *bay;
457
458 if (!(bay = c3600_nm_get_info(router,nm_bay)))
459 return(-1);
460
461 /* stop if this bay is still active */
462 if (bay->drv_info != NULL) {
463 vm_error(router->vm,"slot %u still active.\n",nm_bay);
464 return(-1);
465 }
466
467 /* check that this bay is not empty */
468 if (bay->dev_type == NULL) {
469 vm_error(router->vm,"slot %u is empty.\n",nm_bay);
470 return(-1);
471 }
472
473 /* remove all NIOs bindings */
474 c3600_nm_remove_all_nio_bindings(router,nm_bay);
475
476 bay->dev_type = NULL;
477 bay->nm_driver = NULL;
478 return(0);
479 }
480
481 /* Find a NIO binding */
482 struct c3600_nio_binding *
483 c3600_nm_find_nio_binding(c3600_t *router,u_int nm_bay,u_int port_id)
484 {
485 struct c3600_nio_binding *nb;
486 struct c3600_nm_bay *bay;
487
488 if (!(bay = c3600_nm_get_info(router,nm_bay)))
489 return NULL;
490
491 for(nb=bay->nio_list;nb;nb=nb->next)
492 if (nb->port_id == port_id)
493 return nb;
494
495 return NULL;
496 }
497
498 /* Add a network IO binding */
499 int c3600_nm_add_nio_binding(c3600_t *router,u_int nm_bay,u_int port_id,
500 char *nio_name)
501 {
502 struct c3600_nio_binding *nb;
503 struct c3600_nm_bay *bay;
504 netio_desc_t *nio;
505
506 if (!(bay = c3600_nm_get_info(router,nm_bay)))
507 return(-1);
508
509 /* check that a NIO is not already bound to this port */
510 if (c3600_nm_find_nio_binding(router,nm_bay,port_id) != NULL) {
511 vm_error(router->vm,"a NIO already exists for interface %u/%u.\n",
512 nm_bay,port_id);
513 return(-1);
514 }
515
516 /* acquire a reference on the NIO object */
517 if (!(nio = netio_acquire(nio_name))) {
518 vm_error(router->vm,"unable to find NIO '%s'.\n",nio_name);
519 return(-1);
520 }
521
522 /* create a new binding */
523 if (!(nb = malloc(sizeof(*nb)))) {
524 vm_error(router->vm,"unable to create NIO binding "
525 "for interface %u/%u.\n",nm_bay,port_id);
526 netio_release(nio_name);
527 return(-1);
528 }
529
530 memset(nb,0,sizeof(*nb));
531 nb->nio = nio;
532 nb->port_id = port_id;
533 nb->next = bay->nio_list;
534 if (nb->next) nb->next->prev = nb;
535 bay->nio_list = nb;
536 return(0);
537 }
538
539 /* Remove a NIO binding */
540 int c3600_nm_remove_nio_binding(c3600_t *router,u_int nm_bay,u_int port_id)
541 {
542 struct c3600_nio_binding *nb;
543 struct c3600_nm_bay *bay;
544
545 if (!(bay = c3600_nm_get_info(router,nm_bay)))
546 return(-1);
547
548 if (!(nb = c3600_nm_find_nio_binding(router,nm_bay,port_id)))
549 return(-1); /* no nio binding for this slot/port */
550
551 /* tell the NM driver to stop using this NIO */
552 if (bay->nm_driver)
553 bay->nm_driver->nm_unset_nio(router,nm_bay,port_id);
554
555 /* remove this entry from the double linked list */
556 if (nb->next)
557 nb->next->prev = nb->prev;
558
559 if (nb->prev) {
560 nb->prev->next = nb->next;
561 } else {
562 bay->nio_list = nb->next;
563 }
564
565 /* unreference NIO object */
566 netio_release(nb->nio->name);
567 free(nb);
568 return(0);
569 }
570
571 /* Remove all NIO bindings for the specified NM */
572 int c3600_nm_remove_all_nio_bindings(c3600_t *router,u_int nm_bay)
573 {
574 struct c3600_nio_binding *nb,*next;
575 struct c3600_nm_bay *bay;
576
577 if (!(bay = c3600_nm_get_info(router,nm_bay)))
578 return(-1);
579
580 for(nb=bay->nio_list;nb;nb=next) {
581 next = nb->next;
582
583 /* tell the NM driver to stop using this NIO */
584 if (bay->nm_driver)
585 bay->nm_driver->nm_unset_nio(router,nm_bay,nb->port_id);
586
587 /* unreference NIO object */
588 netio_release(nb->nio->name);
589 free(nb);
590 }
591
592 bay->nio_list = NULL;
593 return(0);
594 }
595
596 /* Enable a Network IO descriptor for a Network Module */
597 int c3600_nm_enable_nio(c3600_t *router,u_int nm_bay,u_int port_id)
598 {
599 struct c3600_nio_binding *nb;
600 struct c3600_nm_bay *bay;
601
602 if (!(bay = c3600_nm_get_info(router,nm_bay)))
603 return(-1);
604
605 /* check that we have an NIO binding for this interface */
606 if (!(nb = c3600_nm_find_nio_binding(router,nm_bay,port_id)))
607 return(-1);
608
609 /* check that the driver is defined and successfully initialized */
610 if (!bay->nm_driver || !bay->drv_info)
611 return(-1);
612
613 return(bay->nm_driver->nm_set_nio(router,nm_bay,port_id,nb->nio));
614 }
615
616 /* Disable Network IO descriptor of a Network Module */
617 int c3600_nm_disable_nio(c3600_t *router,u_int nm_bay,u_int port_id)
618 {
619 struct c3600_nm_bay *bay;
620
621 if (!(bay = c3600_nm_get_info(router,nm_bay)))
622 return(-1);
623
624 /* check that the driver is defined and successfully initialized */
625 if (!bay->nm_driver || !bay->drv_info)
626 return(-1);
627
628 return(bay->nm_driver->nm_unset_nio(router,nm_bay,port_id));
629 }
630
631 /* Enable all NIO of the specified NM */
632 int c3600_nm_enable_all_nio(c3600_t *router,u_int nm_bay)
633 {
634 struct c3600_nio_binding *nb;
635 struct c3600_nm_bay *bay;
636
637 if (!(bay = c3600_nm_get_info(router,nm_bay)))
638 return(-1);
639
640 /* check that the driver is defined and successfully initialized */
641 if (!bay->nm_driver || !bay->drv_info)
642 return(-1);
643
644 for(nb=bay->nio_list;nb;nb=nb->next)
645 bay->nm_driver->nm_set_nio(router,nm_bay,nb->port_id,nb->nio);
646
647 return(0);
648 }
649
650 /* Disable all NIO of the specified NM */
651 int c3600_nm_disable_all_nio(c3600_t *router,u_int nm_bay)
652 {
653 struct c3600_nio_binding *nb;
654 struct c3600_nm_bay *bay;
655
656 if (!(bay = c3600_nm_get_info(router,nm_bay)))
657 return(-1);
658
659 /* check that the driver is defined and successfully initialized */
660 if (!bay->nm_driver || !bay->drv_info)
661 return(-1);
662
663 for(nb=bay->nio_list;nb;nb=nb->next)
664 bay->nm_driver->nm_unset_nio(router,nm_bay,nb->port_id);
665
666 return(0);
667 }
668
669 /* Initialize a Network Module */
670 int c3600_nm_init(c3600_t *router,u_int nm_bay)
671 {
672 struct c3600_nm_bay *bay;
673 size_t len;
674
675 if (!(bay = c3600_nm_get_info(router,nm_bay)))
676 return(-1);
677
678 /* Check that a device type is defined for this bay */
679 if (!bay->dev_type || !bay->nm_driver) {
680 vm_error(router->vm,"trying to init empty slot %u.\n",nm_bay);
681 return(-1);
682 }
683
684 /* Allocate device name */
685 len = strlen(bay->dev_type) + 10;
686 if (!(bay->dev_name = malloc(len))) {
687 vm_error(router->vm,"unable to allocate device name.\n");
688 return(-1);
689 }
690
691 snprintf(bay->dev_name,len,"%s(%u)",bay->dev_type,nm_bay);
692
693 /* Initialize NM driver */
694 if (bay->nm_driver->nm_init(router,bay->dev_name,nm_bay) == 1) {
695 vm_error(router->vm,"unable to initialize NM %u.\n",nm_bay);
696 return(-1);
697 }
698
699 /* Enable all NIO */
700 c3600_nm_enable_all_nio(router,nm_bay);
701 return(0);
702 }
703
704 /* Shutdown a Network Module */
705 int c3600_nm_shutdown(c3600_t *router,u_int nm_bay)
706 {
707 struct c3600_nm_bay *bay;
708
709 if (!(bay = c3600_nm_get_info(router,nm_bay)))
710 return(-1);
711
712 /* Check that a device type is defined for this bay */
713 if (!bay->dev_type || !bay->nm_driver) {
714 vm_error(router->vm,"trying to shut down empty slot %u.\n",nm_bay);
715 return(-1);
716 }
717
718 /* Disable all NIO */
719 c3600_nm_disable_all_nio(router,nm_bay);
720
721 /* Shutdown the NM driver */
722 if (bay->drv_info && (bay->nm_driver->nm_shutdown(router,nm_bay) == -1)) {
723 vm_error(router->vm,"unable to shutdown NM %u.\n",nm_bay);
724 return(-1);
725 }
726
727 free(bay->dev_name);
728 bay->dev_name = NULL;
729 bay->drv_info = NULL;
730 return(0);
731 }
732
733 /* Shutdown all NM of a router */
734 int c3600_nm_shutdown_all(c3600_t *router)
735 {
736 int i;
737
738 for(i=0;i<C3600_MAX_NM_BAYS;i++) {
739 if (!router->nm_bay[i].dev_type)
740 continue;
741
742 c3600_nm_shutdown(router,i);
743 }
744
745 return(0);
746 }
747
748 /* Maximum number of tokens in a NM description */
749 #define NM_DESC_MAX_TOKENS 8
750
751 /* Create a Network Module (command line) */
752 int c3600_cmd_nm_create(c3600_t *router,char *str)
753 {
754 char *tokens[NM_DESC_MAX_TOKENS];
755 int i,count,res;
756 u_int nm_bay;
757
758 /* A port adapter description is like "1:NM-1FE" */
759 if ((count = m_strsplit(str,':',tokens,NM_DESC_MAX_TOKENS)) != 2) {
760 vm_error(router->vm,"unable to parse NM description '%s'.\n",str);
761 return(-1);
762 }
763
764 /* Parse the NM bay id */
765 nm_bay = atoi(tokens[0]);
766
767 /* Add this new NM to the current NM list */
768 res = c3600_nm_add_binding(router,tokens[1],nm_bay);
769
770 /* The complete array was cleaned by strsplit */
771 for(i=0;i<NM_DESC_MAX_TOKENS;i++)
772 free(tokens[i]);
773
774 return(res);
775 }
776
777 /* Add a Network IO descriptor binding (command line) */
778 int c3600_cmd_add_nio(c3600_t *router,char *str)
779 {
780 char *tokens[NM_DESC_MAX_TOKENS];
781 int i,count,nio_type,res=-1;
782 u_int nm_bay,port_id;
783 netio_desc_t *nio;
784 char nio_name[128];
785
786 /* A port adapter description is like "1:3:tap:tap0" */
787 if ((count = m_strsplit(str,':',tokens,NM_DESC_MAX_TOKENS)) < 3) {
788 vm_error(router->vm,"unable to parse NIO description '%s'.\n",str);
789 return(-1);
790 }
791
792 /* Parse the NM bay */
793 nm_bay = atoi(tokens[0]);
794
795 /* Parse the NM port id */
796 port_id = atoi(tokens[1]);
797
798 /* Autogenerate a NIO name */
799 snprintf(nio_name,sizeof(nio_name),"c3600-i%u/%u/%u",
800 router->vm->instance_id,nm_bay,port_id);
801
802 /* Create the Network IO descriptor */
803 nio = NULL;
804 nio_type = netio_get_type(tokens[2]);
805
806 switch(nio_type) {
807 case NETIO_TYPE_UNIX:
808 if (count != 5) {
809 vm_error(router->vm,
810 "invalid number of arguments for UNIX NIO '%s'\n",str);
811 goto done;
812 }
813
814 nio = netio_desc_create_unix(nio_name,tokens[3],tokens[4]);
815 break;
816
817 case NETIO_TYPE_VDE:
818 if (count != 5) {
819 vm_error(router->vm,
820 "invalid number of arguments for VDE NIO '%s'\n",str);
821 goto done;
822 }
823
824 nio = netio_desc_create_vde(nio_name,tokens[3],tokens[4]);
825 break;
826
827 case NETIO_TYPE_TAP:
828 if (count != 4) {
829 vm_error(router->vm,
830 "invalid number of arguments for TAP NIO '%s'\n",str);
831 goto done;
832 }
833
834 nio = netio_desc_create_tap(nio_name,tokens[3]);
835 break;
836
837 case NETIO_TYPE_UDP:
838 if (count != 6) {
839 vm_error(router->vm,
840 "invalid number of arguments for UDP NIO '%s'\n",str);
841 goto done;
842 }
843
844 nio = netio_desc_create_udp(nio_name,atoi(tokens[3]),
845 tokens[4],atoi(tokens[5]));
846 break;
847
848 case NETIO_TYPE_TCP_CLI:
849 if (count != 5) {
850 vm_error(router->vm,
851 "invalid number of arguments for TCP CLI NIO '%s'\n",str);
852 goto done;
853 }
854
855 nio = netio_desc_create_tcp_cli(nio_name,tokens[3],tokens[4]);
856 break;
857
858 case NETIO_TYPE_TCP_SER:
859 if (count != 4) {
860 vm_error(router->vm,
861 "invalid number of arguments for TCP SER NIO '%s'\n",str);
862 goto done;
863 }
864
865 nio = netio_desc_create_tcp_ser(nio_name,tokens[3]);
866 break;
867
868 case NETIO_TYPE_NULL:
869 nio = netio_desc_create_null(nio_name);
870 break;
871
872 #ifdef LINUX_ETH
873 case NETIO_TYPE_LINUX_ETH:
874 if (count != 4) {
875 vm_error(router->vm,
876 "invalid number of arguments for Linux Eth NIO '%s'\n",
877 str);
878 goto done;
879 }
880
881 nio = netio_desc_create_lnxeth(nio_name,tokens[3]);
882 break;
883 #endif
884
885 #ifdef GEN_ETH
886 case NETIO_TYPE_GEN_ETH:
887 if (count != 4) {
888 vm_error(router->vm,
889 "invalid number of arguments for Generic Eth NIO '%s'\n",
890 str);
891 goto done;
892 }
893
894 nio = netio_desc_create_geneth(nio_name,tokens[3]);
895 break;
896 #endif
897
898 default:
899 vm_error(router->vm,"unknown NETIO type '%s'\n",tokens[2]);
900 goto done;
901 }
902
903 if (!nio) {
904 vm_error(router->vm,"unable to create NETIO "
905 "descriptor for NM slot %u\n",nm_bay);
906 goto done;
907 }
908
909 if (c3600_nm_add_nio_binding(router,nm_bay,port_id,nio_name) == -1) {
910 vm_error(router->vm,"unable to add NETIO binding for slot %u\n",nm_bay);
911 netio_release(nio_name);
912 netio_delete(nio_name);
913 goto done;
914 }
915
916 netio_release(nio_name);
917 res = 0;
918
919 done:
920 /* The complete array was cleaned by strsplit */
921 for(i=0;i<NM_DESC_MAX_TOKENS;i++)
922 free(tokens[i]);
923
924 return(res);
925 }
926
927 /* Show the list of available NM drivers */
928 void c3600_nm_show_drivers(void)
929 {
930 int i;
931
932 printf("Available C3600 Network Module drivers:\n");
933
934 for(i=0;nm_drivers[i];i++) {
935 printf(" * %s %s\n",
936 nm_drivers[i]->dev_type,
937 !nm_drivers[i]->supported ? "(NOT WORKING)" : "");
938 }
939
940 printf("\n");
941 }
942
943 /* Get a chassis driver */
944 struct c3600_chassis_driver *c3600_chassis_get_driver(char *chassis_type)
945 {
946 int i;
947
948 for(i=0;chassis_drivers[i].chassis_type;i++)
949 if (!strcmp(chassis_drivers[i].chassis_type,chassis_type))
950 return(&chassis_drivers[i]);
951
952 return NULL;
953 }
954
955 /* Set the base MAC address of the chassis */
956 static int c3600_burn_mac_addr(m_uint16_t *data,size_t data_len,
957 n_eth_addr_t *addr)
958 {
959 m_uint8_t eeprom_ver;
960 size_t offset;
961
962 /* Read EEPROM format version */
963 cisco_eeprom_get_byte(data,data_len,0,&eeprom_ver);
964
965 switch(eeprom_ver) {
966 case 0:
967 cisco_eeprom_set_region(data,data_len,2,addr->eth_addr_byte,6);
968 break;
969
970 case 4:
971 if (!cisco_eeprom_v4_find_field(data,data_len,0xC3,&offset)) {
972 cisco_eeprom_set_region(data,data_len,offset,
973 addr->eth_addr_byte,6);
974 }
975 break;
976
977 default:
978 fprintf(stderr,"c3600_burn_mac_addr: unable to handle "
979 "EEPROM version %u\n",eeprom_ver);
980 return(-1);
981 }
982
983 return(0);
984 }
985
986 /* Set chassis MAC address */
987 int c3600_chassis_set_mac_addr(c3600_t *router,char *mac_addr)
988 {
989 if (parse_mac_addr(&router->mac_addr,mac_addr) == -1) {
990 vm_error(router->vm,"unable to parse MAC address '%s'.\n",mac_addr);
991 return(-1);
992 }
993
994 /* Set the chassis base MAC address */
995 c3600_burn_mac_addr(router->mb_eeprom_data,sizeof(router->mb_eeprom_data),
996 &router->mac_addr);
997 return(0);
998 }
999
1000 /* Set the chassis type */
1001 int c3600_chassis_set_type(c3600_t *router,char *chassis_type)
1002 {
1003 struct c3600_chassis_driver *driver;
1004
1005 if (router->vm->status == VM_STATUS_RUNNING) {
1006 vm_error(router->vm,"unable to change chassis type when online.\n");
1007 return(-1);
1008 }
1009
1010 if (!(driver = c3600_chassis_get_driver(chassis_type))) {
1011 vm_error(router->vm,"unknown chassis type '%s'.\n",chassis_type);
1012 return(-1);
1013 }
1014
1015 router->chassis_driver = driver;
1016
1017 /* Copy the mainboard EEPROM */
1018 memcpy(router->mb_eeprom_data,driver->mb_eeprom,driver->mb_eeprom_len << 1);
1019
1020 /* Set the chassis base MAC address */
1021 c3600_burn_mac_addr(router->mb_eeprom_data,sizeof(router->mb_eeprom_data),
1022 &router->mac_addr);
1023
1024 router->mb_eeprom.data = router->mb_eeprom_data;
1025 router->mb_eeprom.data_len = driver->mb_eeprom_len;
1026 return(0);
1027 }
1028
1029 /* Get the chassis ID */
1030 int c3600_chassis_get_id(c3600_t *router)
1031 {
1032 if (router->chassis_driver)
1033 return(router->chassis_driver->chassis_id);
1034
1035 return(-1);
1036 }
1037
1038 /* Show the list of available chassis drivers */
1039 void c3600_chassis_show_drivers(void)
1040 {
1041 int i;
1042
1043 printf("Available C3600 chassis drivers:\n");
1044
1045 for(i=0;chassis_drivers[i].chassis_type;i++) {
1046 printf(" * %s %s\n",
1047 chassis_drivers[i].chassis_type,
1048 !chassis_drivers[i].supported ? "(NOT WORKING)" : "");
1049 }
1050
1051 printf("\n");
1052 }
1053
1054 /* Create the main PCI bus for a GT64010 based system */
1055 static int c3600_init_gt64010(c3600_t *router)
1056 {
1057 if (!(router->vm->pci_bus[0] = pci_bus_create("PCI bus",0))) {
1058 vm_error(router->vm,"unable to create PCI data.\n");
1059 return(-1);
1060 }
1061
1062 return(dev_gt64010_init(router->vm,"gt64010",C3600_GT64K_ADDR,0x1000,
1063 C3600_GT64K_IRQ));
1064 }
1065
1066 /* Create the two main PCI busses for a GT64120 based system */
1067 static int c3600_init_gt64120(c3600_t *router)
1068 {
1069 vm_instance_t *vm = router->vm;
1070
1071 vm->pci_bus[0] = pci_bus_create("PCI bus #0",0);
1072 vm->pci_bus[1] = pci_bus_create("PCI bus #1",0);
1073
1074 if (!vm->pci_bus[0] || !vm->pci_bus[1]) {
1075 vm_error(router->vm,"unable to create PCI data.\n");
1076 return(-1);
1077 }
1078
1079 return(dev_gt64120_init(vm,"gt64120",C3600_GT64K_ADDR,0x1000,
1080 C3600_GT64K_IRQ));
1081 }
1082
1083 /* Initialize a Cisco 3620 */
1084 static int c3620_init(c3600_t *router)
1085 {
1086 vm_instance_t *vm = router->vm;
1087 int i;
1088
1089 /* Set the processor type: R4700 */
1090 mips64_set_prid(vm->boot_cpu,MIPS_PRID_R4700);
1091
1092 /* Initialize the Galileo GT-64010 PCI controller */
1093 if (c3600_init_gt64010(router) == -1)
1094 return(-1);
1095
1096 /* Initialize PCI map (no PCI bridge for this chassis) */
1097 for(i=0;i<C3600_MAX_NM_BAYS;i++)
1098 router->nm_bay[i].pci_map = vm->pci_bus[0];
1099
1100 vm->elf_machine_id = C3620_ELF_MACHINE_ID;
1101 return(0);
1102 }
1103
1104 /* Initialize a Cisco 3640 */
1105 static int c3640_init(c3600_t *router)
1106 {
1107 vm_instance_t *vm = router->vm;
1108 struct nm_bay_info *bay;
1109 int i;
1110
1111 /* Set the processor type: R4700 */
1112 mips64_set_prid(vm->boot_cpu,MIPS_PRID_R4700);
1113
1114 /* Initialize the Galileo GT-64010 PCI controller */
1115 if (c3600_init_gt64010(router) == -1)
1116 return(-1);
1117
1118 /* Create the NM PCI busses */
1119 vm->pci_bus_pool[0] = pci_bus_create("NM Slots 0,2",-1);
1120 vm->pci_bus_pool[1] = pci_bus_create("NM Slots 1,3",-1);
1121
1122 /* Initialize PCI map and PCI bridges */
1123 for(i=0;i<=3;i++) {
1124 bay = c3600_nm_get_bay_info(3640,i);
1125
1126 /* Map the NM PCI bus */
1127 router->nm_bay[i].pci_map = vm->pci_bus_pool[i & 1];
1128
1129 if (bay && (bay->pci_bridge_device != -1))
1130 dev_dec21052_init(vm->pci_bus[0],bay->pci_bridge_device,
1131 router->nm_bay[i].pci_map);
1132 }
1133
1134 vm->elf_machine_id = C3640_ELF_MACHINE_ID;
1135 return(0);
1136 }
1137
1138 /* Initialize a Cisco 3660 */
1139 static int c3660_init(c3600_t *router)
1140 {
1141 vm_instance_t *vm = router->vm;
1142 struct nm_bay_info *bay;
1143 char bus_name[128];
1144 int i;
1145
1146 /* Set the processor type: R5271 */
1147 mips64_set_prid(vm->boot_cpu,MIPS_PRID_R527x);
1148
1149 /* Initialize the Galileo GT-64120 PCI controller */
1150 if (c3600_init_gt64120(router) == -1)
1151 return(-1);
1152
1153 /* Create the NM PCI busses */
1154 for(i=1;i<=6;i++) {
1155 snprintf(bus_name,sizeof(bus_name),"NM Slot %d",i);
1156 vm->pci_bus_pool[i] = pci_bus_create(bus_name,-1);
1157 }
1158
1159 /* Slot 0 is mapped to the first bus of GT64120 */
1160 router->nm_bay[0].pci_map = vm->pci_bus[0];
1161
1162 /* Initialize PCI map and PCI bridges */
1163 for(i=1;i<C3600_MAX_NM_BAYS;i++) {
1164 bay = c3600_nm_get_bay_info(3660,i);
1165
1166 /* Map the NM PCI bus */
1167 router->nm_bay[i].pci_map = vm->pci_bus_pool[i];
1168
1169 /* Slots 1-6 are mapped to the second bus of GT64120 */
1170 if (bay && (bay->pci_bridge_device != -1))
1171 dev_dec21152_init(vm->pci_bus[1],bay->pci_bridge_device,
1172 router->nm_bay[i].pci_map);
1173 }
1174
1175 /* The motherboard has 2 integrated FastEthernet ports */
1176 c3600_nm_add_binding(router,"Leopard-2FE",0);
1177
1178 vm->elf_machine_id = C3640_ELF_MACHINE_ID;
1179 return(0);
1180 }
1181
1182 /* Show C3600 hardware info */
1183 void c3600_show_hardware(c3600_t *router)
1184 {
1185 vm_instance_t *vm = router->vm;
1186
1187 printf("C3600 instance '%s' (id %d):\n",vm->name,vm->instance_id);
1188
1189 printf(" VM Status : %d\n",vm->status);
1190 printf(" RAM size : %u Mb\n",vm->ram_size);
1191 printf(" NVRAM size : %u Kb\n",vm->nvram_size);
1192 printf(" Chassis : %s\n",router->chassis_driver->chassis_type);
1193 printf(" IOS image : %s\n\n",vm->ios_image);
1194
1195 if (vm->debug_level > 0) {
1196 dev_show_list(vm);
1197 pci_dev_show_list(vm->pci_bus[0]);
1198 pci_dev_show_list(vm->pci_bus[1]);
1199 printf("\n");
1200 }
1201 }
1202
1203 /* Initialize default parameters for a C3600 */
1204 void c3600_init_defaults(c3600_t *router)
1205 {
1206 vm_instance_t *vm = router->vm;
1207 n_eth_addr_t *m;
1208 m_uint16_t pid;
1209
1210 pid = (m_uint16_t)getpid();
1211
1212 /* Generate a chassis MAC address based on the instance ID */
1213 m = &router->mac_addr;
1214 m->eth_addr_byte[0] = 0xCC;
1215 m->eth_addr_byte[1] = vm->instance_id & 0xFF;
1216 m->eth_addr_byte[2] = pid >> 8;
1217 m->eth_addr_byte[3] = pid & 0xFF;
1218 m->eth_addr_byte[4] = 0x00;
1219 m->eth_addr_byte[5] = 0x00;
1220
1221 c3600_init_eeprom_groups(router);
1222 c3600_chassis_set_type(router,C3600_DEFAULT_CHASSIS);
1223
1224 vm->ram_mmap = C3600_DEFAULT_RAM_MMAP;
1225 vm->ram_size = C3600_DEFAULT_RAM_SIZE;
1226 vm->rom_size = C3600_DEFAULT_ROM_SIZE;
1227 vm->nvram_size = C3600_DEFAULT_NVRAM_SIZE;
1228 vm->conf_reg = C3600_DEFAULT_CONF_REG;
1229 vm->clock_divisor = C3600_DEFAULT_CLOCK_DIV;
1230 vm->nvram_rom_space = C3600_NVRAM_ROM_RES_SIZE;
1231 router->nm_iomem_size = C3600_DEFAULT_IOMEM_SIZE;
1232
1233 vm->pcmcia_disk_size[0] = C3600_DEFAULT_DISK0_SIZE;
1234 vm->pcmcia_disk_size[1] = C3600_DEFAULT_DISK1_SIZE;
1235 }
1236
1237 /* Initialize the C3600 Platform */
1238 int c3600_init_platform(c3600_t *router)
1239 {
1240 vm_instance_t *vm = router->vm;
1241 struct c3600_nm_bay *nm_bay;
1242 cpu_mips_t *cpu;
1243 int i;
1244
1245 /* Copy config register setup into "active" config register */
1246 vm->conf_reg = vm->conf_reg_setup;
1247
1248 /* Create Console and AUX ports */
1249 vm_init_vtty(vm);
1250
1251 /* Create a CPU group */
1252 vm->cpu_group = cpu_group_create("System CPU");
1253
1254 /* Initialize the virtual MIPS processor */
1255 if (!(cpu = cpu_create(vm,0))) {
1256 vm_error(vm,"unable to create CPU!\n");
1257 return(-1);
1258 }
1259
1260 /* Add this CPU to the system CPU group */
1261 cpu_group_add(vm->cpu_group,cpu);
1262 vm->boot_cpu = cpu;
1263
1264 /* Mark the Network IO interrupt as high priority */
1265 cpu->irq_idle_preempt[C3600_NETIO_IRQ] = TRUE;
1266 cpu->irq_idle_preempt[C3600_DUART_IRQ] = TRUE;
1267
1268 /* Copy some parameters from VM to CPU (idle PC, ...) */
1269 cpu->idle_pc = vm->idle_pc;
1270
1271 if (vm->timer_irq_check_itv)
1272 cpu->timer_irq_check_itv = vm->timer_irq_check_itv;
1273
1274 /* Get chassis specific driver */
1275 if (!router->chassis_driver) {
1276 vm_error(vm,"no chassis defined.\n");
1277 return(-1);
1278 }
1279
1280 /* Remote emulator control */
1281 dev_remote_control_init(vm,0x16000000,0x1000);
1282
1283 /* Bootflash */
1284 dev_bootflash_init(vm,"bootflash",C3600_BOOTFLASH_ADDR,(8 * 1048576));
1285
1286 /* NVRAM and calendar */
1287 dev_nvram_init(vm,"nvram",
1288 C3600_NVRAM_ADDR,vm->nvram_size*1024,&vm->conf_reg);
1289
1290 /* Bit-bucket zone */
1291 dev_zero_init(vm,"zero",C3600_BITBUCKET_ADDR,0xc00000);
1292
1293 /* IO FPGA */
1294 if (dev_c3600_iofpga_init(router,C3600_IOFPGA_ADDR,0x40000) == -1)
1295 return(-1);
1296
1297 /* PCI IO space */
1298 if (!(vm->pci_io_space = pci_io_data_init(vm,C3600_PCI_IO_ADDR)))
1299 return(-1);
1300
1301 /* Initialize the chassis */
1302 if (router->chassis_driver->chassis_init(router) == -1)
1303 return(-1);
1304
1305 /* Initialize RAM */
1306 dev_ram_init(vm,"ram",vm->ram_mmap,0x00000000ULL,vm->ram_size*1048576);
1307
1308 /* Initialize ROM */
1309 if (!vm->rom_filename) {
1310 /* use embedded ROM */
1311 dev_rom_init(vm,"rom",C3600_ROM_ADDR,vm->rom_size*1048576);
1312 } else {
1313 /* use alternate ROM */
1314 dev_ram_init(vm,"rom",TRUE,C3600_ROM_ADDR,vm->rom_size*1048576);
1315 }
1316
1317 /* Initialize the NS16552 DUART */
1318 dev_ns16552_init(vm,C3600_DUART_ADDR,0x1000,C3600_DUART_IRQ,
1319 vm->vtty_con,vm->vtty_aux);
1320
1321 /* Cirrus Logic PD6729 (PCI-to-PCMCIA host adapter) */
1322 dev_clpd6729_init(vm,vm->pci_bus[0],20,vm->pci_io_space,0x4402,0x4403);
1323
1324 /* Initialize Network Modules */
1325 for(i=0;i<C3600_MAX_NM_BAYS;i++) {
1326 nm_bay = &router->nm_bay[i];
1327
1328 if (!nm_bay->dev_type)
1329 continue;
1330
1331 if (c3600_nm_init(router,i) == -1) {
1332 vm_error(vm,"unable to create Network Module \"%s\"\n",
1333 nm_bay->dev_type);
1334 return(-1);
1335 }
1336 }
1337
1338 /* Enable NVRAM operations to load/store configs */
1339 vm->nvram_extract_config = c3600_nvram_extract_config;
1340 vm->nvram_push_config = c3600_nvram_push_config;
1341
1342 /* Show device list */
1343 c3600_show_hardware(router);
1344 return(0);
1345 }
1346
1347 /* Boot the IOS image */
1348 int c3600_boot_ios(c3600_t *router)
1349 {
1350 vm_instance_t *vm = router->vm;
1351
1352 if (!vm->boot_cpu)
1353 return(-1);
1354
1355 /* Suspend CPU activity since we will restart directly from ROM */
1356 vm_suspend(vm);
1357
1358 /* Check that CPU activity is really suspended */
1359 if (cpu_group_sync_state(vm->cpu_group) == -1) {
1360 vm_error(vm,"unable to sync with system CPUs.\n");
1361 return(-1);
1362 }
1363
1364 /* Reset the boot CPU */
1365 mips64_reset(vm->boot_cpu);
1366
1367 /* Load IOS image */
1368 if (mips64_load_elf_image(vm->boot_cpu,vm->ios_image,
1369 &vm->ios_entry_point) < 0)
1370 {
1371 vm_error(vm,"failed to load Cisco IOS image '%s'.\n",vm->ios_image);
1372 return(-1);
1373 }
1374
1375 /* Launch the simulation */
1376 printf("\nC3600 '%s': starting simulation (CPU0 PC=0x%llx), "
1377 "JIT %sabled.\n",
1378 vm->name,vm->boot_cpu->pc,vm->jit_use ? "en":"dis");
1379
1380 vm_log(vm,"C3600_BOOT",
1381 "starting instance (CPU0 PC=0x%llx,idle_pc=0x%llx,JIT %s)\n",
1382 vm->boot_cpu->pc,vm->boot_cpu->idle_pc,vm->jit_use ? "on":"off");
1383
1384 /* Start main CPU */
1385 vm->status = VM_STATUS_RUNNING;
1386 cpu_start(vm->boot_cpu);
1387 return(0);
1388 }
1389
1390 /* Initialize a Cisco 3600 instance */
1391 int c3600_init_instance(c3600_t *router)
1392 {
1393 vm_instance_t *vm = router->vm;
1394 m_uint32_t rom_entry_point;
1395 cpu_mips_t *cpu0;
1396
1397 if (!vm->ios_image) {
1398 vm_error(vm,"no Cisco IOS image defined.");
1399 return(-1);
1400 }
1401
1402 /* Initialize the C3600 platform */
1403 if (c3600_init_platform(router) == -1) {
1404 vm_error(vm,"unable to initialize the platform hardware.\n");
1405 return(-1);
1406 }
1407
1408 /* Load IOS configuration file */
1409 if (vm->ios_config != NULL) {
1410 vm_nvram_push_config(vm,vm->ios_config);
1411 vm->conf_reg &= ~0x40;
1412 }
1413
1414 /* Load ROM (ELF image or embedded) */
1415 cpu0 = vm->boot_cpu;
1416 rom_entry_point = (m_uint32_t)MIPS_ROM_PC;
1417
1418 if ((vm->rom_filename != NULL) &&
1419 (mips64_load_elf_image(cpu0,vm->rom_filename,&rom_entry_point) < 0))
1420 {
1421 vm_error(vm,"unable to load alternate ROM '%s', "
1422 "fallback to embedded ROM.\n\n",vm->rom_filename);
1423 vm->rom_filename = NULL;
1424 }
1425
1426 /* Load symbol file */
1427 if (vm->sym_filename) {
1428 mips64_sym_load_file(cpu0,vm->sym_filename);
1429 cpu0->sym_trace = 1;
1430 }
1431
1432 return(c3600_boot_ios(router));
1433 }
1434
1435 /* Stop a Cisco 3600 instance */
1436 int c3600_stop_instance(c3600_t *router)
1437 {
1438 vm_instance_t *vm = router->vm;
1439
1440 printf("\nC3600 '%s': stopping simulation.\n",vm->name);
1441 vm_log(vm,"C3600_STOP","stopping simulation.\n");
1442
1443 /* Stop all CPUs */
1444 if (vm->cpu_group != NULL) {
1445 vm_stop(vm);
1446
1447 if (cpu_group_sync_state(vm->cpu_group) == -1) {
1448 vm_error(vm,"unable to sync with system CPUs.\n");
1449 return(-1);
1450 }
1451 }
1452
1453 /* Free resources that were used during execution to emulate hardware */
1454 c3600_nm_shutdown_all(router);
1455 vm_hardware_shutdown(vm);
1456 return(0);
1457 }

  ViewVC Help
Powered by ViewVC 1.1.26