/ - Diff - qemu - Greek Research and Technology Network's projects

b/hw/ads7846.c
140	140	return 0;
141	141	}
142	142
143		static int ads7846_iid = 0;
144
145	143	struct ads7846_state_s *ads7846_init(qemu_irq penirq)
146	144	{
147	145	struct ads7846_state_s *s;
...	...
162	160
163	161	ads7846_int_update(s);
164	162
165		register_savevm("ads7846", ads7846_iid ++, 0,
166		ads7846_save, ads7846_load, s);
	163	register_savevm("ads7846", -1, 0, ads7846_save, ads7846_load, s);
167	164
168	165	return s;
169	166	}

         return 0;
+    }
     static int md_iid = 0;
     static const uint8_t dscm1xxxx_cis[0x14a] = {
         [0x000] = CISTPL_DEVICE,	/* 5V Device Information */
         [0x002] = 0x03,		/* Tuple length = 4 bytes */
-...
         md->ide->mdata_size = METADATA_SIZE;
         md->ide->mdata_storage = (uint8_t *) qemu_mallocz(METADATA_SIZE);
         register_savevm("microdrive", md_iid ++, 0, md_save, md_load, md);
         register_savevm("microdrive", -1, 0, md_save, md_load, md);
         return &md->card;
+    }

b/hw/lm832x.c
490	490	return 0;
491	491	}
492	492
493		static int lm_kbd_iid = 0;
494
495	493	struct i2c_slave lm8323_init(i2c_bus bus, qemu_irq nirq)
496	494	{
497	495	struct lm_kbd_s *s;
...	...
510	508	lm_kbd_reset(s);
511	509
512	510	qemu_register_reset((void *) lm_kbd_reset, s);
513		register_savevm("LM8323", lm_kbd_iid ++, 0,
514		lm_kbd_save, lm_kbd_load, s);
	511	register_savevm("LM8323", -1, 0, lm_kbd_save, lm_kbd_load, s);
515	512
516	513	return &s->i2c;
517	514	}

b/hw/max111x.c
121	121	return 0;
122	122	}
123	123
124		static int max111x_iid = 0;
125
126	124	static struct max111x_s *max111x_init(qemu_irq cb)
127	125	{
128	126	struct max111x_s *s;
...	...
143	141	s->input[7] = 0x80;
144	142	s->com = 0;
145	143
146		register_savevm("max111x", max111x_iid ++, 0,
147		max111x_save, max111x_load, s);
	144	register_savevm("max111x", -1, 0, max111x_save, max111x_load, s);
148	145
149	146	return s;
150	147	}

b/hw/max7310.c
177	177	return 0;
178	178	}
179	179
180		static int max7310_iid = 0;
181
182	180	static void max7310_gpio_set(void *opaque, int line, int level)
183	181	{
184	182	struct max7310_s s = (struct max7310_s ) opaque;
...	...
205	203
206	204	max7310_reset(&s->i2c);
207	205
208		register_savevm("max7310", max7310_iid ++, 0,
209		max7310_save, max7310_load, s);
	206	register_savevm("max7310", -1, 0, max7310_save, max7310_load, s);
210	207
211	208	return &s->i2c;
212	209	}

         return 0;
+    }
     static int nand_iid = 0;
     /*
      * Chip inputs are CLE, ALE, CE, WP, GND and eight I/O pins.  Chip
      * outputs are R/B and eight I/O pins.
-...
             s->storage = (uint8_t *) memset(qemu_malloc(s->pages * pagesize),
 xff, s->pages * pagesize);
         register_savevm("nand", nand_iid ++, 0, nand_save, nand_load, s);
         register_savevm("nand", -1, 0, nand_save, nand_load, s);
         return s;
+    }

b/hw/tmp105.c
228	228	tmp105_interrupt_update(s);
229	229	}
230	230
231		static int tmp105_iid = 0;
232
233	231	struct i2c_slave tmp105_init(i2c_bus bus, qemu_irq alarm)
234	232	{
235	233	struct tmp105_s s = (struct tmp105_s )
...	...
242	240
243	241	tmp105_reset(&s->i2c);
244	242
245		register_savevm("TMP105", tmp105_iid ++, 0,
246		tmp105_save, tmp105_load, s);
	243	register_savevm("TMP105", -1, 0, tmp105_save, tmp105_load, s);
247	244
248	245	return &s->i2c;
249	246	}

b/hw/tsc2005.c
520	520	return 0;
521	521	}
522	522
523		static int tsc2005_iid = 0;
524
525	523	void *tsc2005_init(qemu_irq pintdav)
526	524	{
527	525	struct tsc2005_state_s *s;
...	...
551	549	"QEMU TSC2005-driven Touchscreen");
552	550
553	551	qemu_register_reset((void *) tsc2005_reset, s);
554		register_savevm("tsc2005", tsc2005_iid ++, 0,
555		tsc2005_save, tsc2005_load, s);
	552	register_savevm("tsc2005", -1, 0, tsc2005_save, tsc2005_load, s);
556	553
557	554	return s;
558	555	}

         return 0;
+    }
     static int tsc2102_iid = 0;
     struct uwire_slave_s *tsc2102_init(qemu_irq pint, AudioState *audio)
+    {
         struct tsc210x_state_s *s;
-...
             AUD_register_card(s->audio, s->name, &s->card);
         qemu_register_reset((void *) tsc210x_reset, s);
         register_savevm(s->name, tsc2102_iid ++, 0,
         register_savevm(s->name, -1, 0,
                         tsc210x_save, tsc210x_load, s);
         return &s->chip;
-...
             AUD_register_card(s->audio, s->name, &s->card);
         qemu_register_reset((void *) tsc210x_reset, s);
         register_savevm(s->name, tsc2102_iid ++, 0,
                         tsc210x_save, tsc210x_load, s);
         register_savevm(s->name, -1, 0, tsc210x_save, tsc210x_load, s);
         return &s->chip;
+    }

b/hw/twl92230.c
876	876	return 0;
877	877	}
878	878
879		static int menelaus_iid = 0;
880
881	879	i2c_slave twl92230_init(i2c_bus bus, qemu_irq irq)
882	880	{
883	881	struct menelaus_s s = (struct menelaus_s )
...	...
894	892
895	893	menelaus_reset(&s->i2c);
896	894
897		register_savevm("menelaus", menelaus_iid ++,
898		0, menelaus_save, menelaus_load, s);
	895	register_savevm("menelaus", -1, 0, menelaus_save, menelaus_load, s);
899	896
900	897	return &s->i2c;
901	898	}

b/hw/wm8750.c
646	646	return 0;
647	647	}
648	648
649		static int wm8750_iid = 0;
650
651	649	i2c_slave wm8750_init(i2c_bus bus, AudioState *audio)
652	650	{
653	651	struct wm8750_s s = (struct wm8750_s )
...	...
659	657	AUD_register_card(audio, CODEC, &s->card);
660	658	wm8750_reset(&s->i2c);
661	659
662		register_savevm(CODEC, wm8750_iid ++, 0, wm8750_save, wm8750_load, s);
	660	register_savevm(CODEC, -1, 0, wm8750_save, wm8750_load, s);
663	661
664	662	return &s->i2c;
665	663	}

     static SaveStateEntry *first_se;
     /* TODO: Individual devices generally have very little idea about the rest
        of the system, so instance_id should be removed/replaced.  */
     int register_savevm(const char *idstr,
                         int instance_id,
                         int version_id,
-...
         if (!se)
             return -1;
         pstrcpy(se->idstr, sizeof(se->idstr), idstr);
         se->instance_id = instance_id;
         se->instance_id = (instance_id == -1) ? 0 : instance_id;
         se->version_id = version_id;
         se->save_state = save_state;
         se->load_state = load_state;
-...
         /* add at the end of list */
         pse = &first_se;
         while (*pse != NULL)
         while (*pse != NULL) {
             if (instance_id == -1
                     && strcmp(se->idstr, (*pse)->idstr) == 0
                     && se->instance_id <= (*pse)->instance_id)
                 se->instance_id = (*pse)->instance_id + 1;
             pse = &(*pse)->next;
+        }
         *pse = se;
         return 0;
+    }

Archipelago » qemu