![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to esp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / drivers|
Return to esp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / drivers |
1.1 root 1: /*
2: * OpenBIOS ESP driver
3: *
4: * Copyright (C) 2004 Jens Axboe <[email protected]>
5: * Copyright (C) 2005 Stefan Reinauer <[email protected]>
6: *
7: * Credit goes to Hale Landis for his excellent ata demo software
8: * OF node handling and some fixes by Stefan Reinauer
9: *
10: * This program is free software; you can redistribute it and/or
11: * modify it under the terms of the GNU General Public License
12: * version 2
13: *
14: */
15:
16: #include "config.h"
17: #include "libopenbios/bindings.h"
18: #include "kernel/kernel.h"
19: #include "libc/byteorder.h"
20: #include "libc/vsprintf.h"
21:
22: #include "drivers/drivers.h"
23: #include "asm/io.h"
24: #include "scsi.h"
25: #include "asm/dma.h"
26: #include "esp.h"
27: #include "libopenbios/ofmem.h"
28:
29: #define BUFSIZE 4096
30:
31: #ifdef CONFIG_DEBUG_ESP
32: #define DPRINTF(fmt, args...) \
33: do { printk(fmt , ##args); } while (0)
34: #else
35: #define DPRINTF(fmt, args...)
36: #endif
37:
38: struct esp_dma {
39: volatile struct sparc_dma_registers *regs;
40: enum dvma_rev revision;
41: };
42:
43: typedef struct sd_private {
44: unsigned int bs;
45: const char *media_str[2];
46: uint32_t sectors;
47: uint8_t media;
48: uint8_t id;
49: uint8_t present;
50: char model[40];
51: } sd_private_t;
52:
53: struct esp_regs {
54: unsigned char regs[ESP_REG_SIZE];
55: };
56:
57: typedef struct esp_private {
58: volatile struct esp_regs *ll;
59: uint32_t buffer_dvma;
60: unsigned int irq; /* device IRQ number */
61: struct esp_dma espdma;
62: unsigned char *buffer;
63: sd_private_t sd[8];
64: } esp_private_t;
65:
66: static esp_private_t *global_esp;
67:
68: /* DECLARE data structures for the nodes. */
69: DECLARE_UNNAMED_NODE(ob_sd, INSTALL_OPEN, sizeof(sd_private_t *));
70: DECLARE_UNNAMED_NODE(ob_esp, INSTALL_OPEN, sizeof(esp_private_t *));
71:
72: #ifdef CONFIG_DEBUG_ESP
73: static void dump_drive(sd_private_t *drive)
74: {
75: printk("SCSI DRIVE @%lx:\n", (unsigned long)drive);
76: printk("id: %d\n", drive->id);
77: printk("media: %s\n", drive->media_str[0]);
78: printk("media: %s\n", drive->media_str[1]);
79: printk("model: %s\n", drive->model);
80: printk("sectors: %d\n", drive->sectors);
81: printk("present: %d\n", drive->present);
82: printk("bs: %d\n", drive->bs);
83: }
84: #endif
85:
86: static int
87: do_command(esp_private_t *esp, sd_private_t *sd, int cmdlen, int replylen)
88: {
89: int status;
90:
91: // Set SCSI target
92: esp->ll->regs[ESP_BUSID] = sd->id & 7;
93: // Set DMA address
94: esp->espdma.regs->st_addr = esp->buffer_dvma;
95: // Set DMA length
96: esp->ll->regs[ESP_TCLOW] = cmdlen & 0xff;
97: esp->ll->regs[ESP_TCMED] = (cmdlen >> 8) & 0xff;
98: // Set DMA direction and enable DMA
99: esp->espdma.regs->cond_reg = DMA_ENABLE;
100: // Set ATN, issue command
101: esp->ll->regs[ESP_CMD] = ESP_CMD_SELA | ESP_CMD_DMA;
102: // Wait for DMA to complete. Can this fail?
103: while ((esp->espdma.regs->cond_reg & DMA_HNDL_INTR) == 0) /* no-op */;
104: // Check status
105: status = esp->ll->regs[ESP_STATUS];
106: // Clear interrupts to avoid guests seeing spurious interrupts
107: (void)esp->ll->regs[ESP_INTRPT];
108:
109: DPRINTF("do_command: id %d, cmd[0] 0x%x, status 0x%x\n", sd->id, esp->buffer[0], status);
110:
111: /* Target didn't want all command data? */
112: if ((status & ESP_STAT_TCNT) != ESP_STAT_TCNT) {
113: return status;
114: }
115: if (replylen == 0) {
116: return 0;
117: }
118: /* Target went to status phase instead of data phase? */
119: if ((status & ESP_STAT_PMASK) == ESP_STATP) {
120: return status;
121: }
122:
123: // Get reply
124: // Set DMA address
125: esp->espdma.regs->st_addr = esp->buffer_dvma;
126: // Set DMA length
127: esp->ll->regs[ESP_TCLOW] = replylen & 0xff;
128: esp->ll->regs[ESP_TCMED] = (replylen >> 8) & 0xff;
129: // Set DMA direction
130: esp->espdma.regs->cond_reg = DMA_ST_WRITE | DMA_ENABLE;
131: // Transfer
132: esp->ll->regs[ESP_CMD] = ESP_CMD_TI | ESP_CMD_DMA;
133: // Wait for DMA to complete
134: while ((esp->espdma.regs->cond_reg & DMA_HNDL_INTR) == 0) /* no-op */;
135: // Check status
136: status = esp->ll->regs[ESP_STATUS];
137: // Clear interrupts to avoid guests seeing spurious interrupts
138: (void)esp->ll->regs[ESP_INTRPT];
139:
140: DPRINTF("do_command_reply: status 0x%x\n", status);
141:
142: if ((status & ESP_STAT_TCNT) != ESP_STAT_TCNT)
143: return status;
144: else
145: return 0; // OK
146: }
147:
148: // offset is in sectors
149: static int
150: ob_sd_read_sector(esp_private_t *esp, sd_private_t *sd, int offset)
151: {
152: DPRINTF("ob_sd_read_sector id %d sector=%d\n",
153: sd->id, offset);
154:
155: // Setup command = Read(10)
156: memset(esp->buffer, 0, 11);
157: esp->buffer[0] = 0x80;
158: esp->buffer[1] = READ_10;
159:
160: esp->buffer[3] = (offset >> 24) & 0xff;
161: esp->buffer[4] = (offset >> 16) & 0xff;
162: esp->buffer[5] = (offset >> 8) & 0xff;
163: esp->buffer[6] = offset & 0xff;
164:
165: esp->buffer[8] = 0;
166: esp->buffer[9] = 1;
167:
168: if (do_command(esp, sd, 11, sd->bs))
169: return 0;
170:
171: return 0;
172: }
173:
174: static unsigned int
175: read_capacity(esp_private_t *esp, sd_private_t *sd)
176: {
177: // Setup command = Read Capacity
178: memset(esp->buffer, 0, 11);
179: esp->buffer[0] = 0x80;
180: esp->buffer[1] = READ_CAPACITY;
181:
182: if (do_command(esp, sd, 11, 8)) {
183: sd->sectors = 0;
184: sd->bs = 0;
185: DPRINTF("read_capacity id %d failed\n", sd->id);
186: return 0;
187: }
188: sd->bs = (esp->buffer[4] << 24) | (esp->buffer[5] << 16) | (esp->buffer[6] << 8) | esp->buffer[7];
189: sd->sectors = ((esp->buffer[0] << 24) | (esp->buffer[1] << 16) | (esp->buffer[2] << 8) | esp->buffer[3]) * (sd->bs / 512);
190:
191: DPRINTF("read_capacity id %d bs %d sectors %d\n", sd->id, sd->bs,
192: sd->sectors);
193: return 1;
194: }
195:
196: static unsigned int
197: test_unit_ready(esp_private_t *esp, sd_private_t *sd)
198: {
199: /* Setup command = Test Unit Ready */
200: memset(esp->buffer, 0, 6);
201: esp->buffer[0] = 0x80;
202: esp->buffer[1] = TEST_UNIT_READY;
203:
204: if (do_command(esp, sd, 6, 0)) {
205: DPRINTF("test_unit_ready id %d failed\n", sd->id);
206: return 0;
207: }
208:
209: DPRINTF("test_unit_ready id %d success\n", sd->id);
210: return 1;
211: }
212:
213: static unsigned int
214: inquiry(esp_private_t *esp, sd_private_t *sd)
215: {
216: const char *media[2] = { "UNKNOWN", "UNKNOWN"};
217:
218: // Setup command = Inquiry
219: memset(esp->buffer, 0, 7);
220: esp->buffer[0] = 0x80;
221: esp->buffer[1] = INQUIRY;
222:
223: esp->buffer[5] = 36;
224:
225: if (do_command(esp, sd, 7, 36)) {
226: sd->present = 0;
227: sd->media = -1;
228: return 0;
229: }
230: sd->present = 1;
231: sd->media = esp->buffer[0];
232:
233: switch (sd->media) {
234: case TYPE_DISK:
235: media[0] = "disk";
236: media[1] = "hd";
237: break;
238: case TYPE_ROM:
239: media[0] = "cdrom";
240: media[1] = "cd";
241: break;
242: }
243: sd->media_str[0] = media[0];
244: sd->media_str[1] = media[1];
245: memcpy(sd->model, &esp->buffer[16], 16);
246: sd->model[17] = '\0';
247:
248: return 1;
249: }
250:
251:
252: static void
253: ob_sd_read_blocks(sd_private_t **sd)
254: {
255: cell n = POP(), cnt = n;
256: ucell blk = POP();
257: char *dest = (char*)POP();
258: int pos, spb, sect_offset;
259:
260: DPRINTF("ob_sd_read_blocks id %d %lx block=%d n=%d\n", (*sd)->id, (unsigned long)dest, blk, n );
261:
262: if ((*sd)->bs == 0) {
263: PUSH(0);
264: return;
265: }
266: spb = (*sd)->bs / 512;
267: while (n) {
268: sect_offset = blk / spb;
269: pos = (blk - sect_offset * spb) * 512;
270:
271: if (ob_sd_read_sector(global_esp, *sd, sect_offset)) {
272: DPRINTF("ob_sd_read_blocks: error\n");
273: RET(0);
274: }
275: while (n && pos < spb * 512) {
276: memcpy(dest, global_esp->buffer + pos, 512);
277: pos += 512;
278: dest += 512;
279: n--;
280: blk++;
281: }
282: }
283: PUSH(cnt);
284: }
285:
286: static void
287: ob_sd_block_size(__attribute__((unused))sd_private_t **sd)
288: {
289: PUSH(512);
290: }
291:
292: static void
293: ob_sd_open(__attribute__((unused))sd_private_t **sd)
294: {
295: int ret = 1, id;
296: phandle_t ph;
297:
298: fword("my-unit");
299: id = POP();
300: POP(); // unit id is 2 ints but we only need one.
301: *sd = &global_esp->sd[id];
302:
303: #ifdef CONFIG_DEBUG_ESP
304: {
305: char *args;
306:
307: fword("my-args");
308: args = pop_fstr_copy();
309: DPRINTF("opening drive %d args %s\n", id, args);
310: free(args);
311: }
312: #endif
313:
314: selfword("open-deblocker");
315:
316: /* interpose disk-label */
317: ph = find_dev("/packages/disk-label");
318: fword("my-args");
319: PUSH_ph( ph );
320: fword("interpose");
321:
322: RET ( -ret );
323: }
324:
325: static void
326: ob_sd_close(__attribute__((unused)) sd_private_t **sd)
327: {
328: selfword("close-deblocker");
329: }
330:
331: NODE_METHODS(ob_sd) = {
332: { "open", ob_sd_open },
333: { "close", ob_sd_close },
334: { "read-blocks", ob_sd_read_blocks },
335: { "block-size", ob_sd_block_size },
336: };
337:
338:
339: static int
340: espdma_init(unsigned int slot, uint64_t base, unsigned long offset,
341: struct esp_dma *espdma)
342: {
343: espdma->regs = (void *)ofmem_map_io(base + (uint64_t)offset, 0x10);
344:
345: if (espdma->regs == NULL) {
346: DPRINTF("espdma_init: cannot map registers\n");
347: return -1;
348: }
349:
350: DPRINTF("dma1: ");
351:
352: switch ((espdma->regs->cond_reg) & DMA_DEVICE_ID) {
353: case DMA_VERS0:
354: espdma->revision = dvmarev0;
355: DPRINTF("Revision 0 ");
356: break;
357: case DMA_ESCV1:
358: espdma->revision = dvmaesc1;
359: DPRINTF("ESC Revision 1 ");
360: break;
361: case DMA_VERS1:
362: espdma->revision = dvmarev1;
363: DPRINTF("Revision 1 ");
364: break;
365: case DMA_VERS2:
366: espdma->revision = dvmarev2;
367: DPRINTF("Revision 2 ");
368: break;
369: case DMA_VERHME:
370: espdma->revision = dvmahme;
371: DPRINTF("HME DVMA gate array ");
372: break;
373: case DMA_VERSPLUS:
374: espdma->revision = dvmarevplus;
375: DPRINTF("Revision 1 PLUS ");
376: break;
377: default:
378: DPRINTF("unknown dma version %x",
379: (espdma->regs->cond_reg) & DMA_DEVICE_ID);
380: /* espdma->allocated = 1; */
381: break;
382: }
383: DPRINTF("\n");
384:
385: push_str("/iommu/sbus/espdma");
386: fword("find-device");
387:
388: /* set reg */
389: PUSH(slot);
390: fword("encode-int");
391: PUSH(offset);
392: fword("encode-int");
393: fword("encode+");
394: PUSH(0x00000010);
395: fword("encode-int");
396: fword("encode+");
397: push_str("reg");
398: fword("property");
399:
400: return 0;
401: }
402:
403: static void
404: ob_esp_initialize(__attribute__((unused)) esp_private_t **esp)
405: {
406: phandle_t ph = get_cur_dev();
407:
408: set_int_property(ph, "#address-cells", 2);
409: set_int_property(ph, "#size-cells", 0);
410:
411: /* set device type */
412: push_str("scsi");
413: fword("device-type");
414:
415: /* QEMU's ESP emulation does not support mixing DMA and FIFO messages. By
416: setting this attribute, we prevent the Solaris ESP kernel driver from
417: trying to use this feature when booting a disk image (and failing) */
418: PUSH(0x58);
419: fword("encode-int");
420: push_str("scsi-options");
421: fword("property");
422:
423: PUSH(0x24);
424: fword("encode-int");
425: PUSH(0);
426: fword("encode-int");
427: fword("encode+");
428: push_str("intr");
429: fword("property");
430: }
431:
432: static void
433: ob_esp_decodeunit(__attribute__((unused)) esp_private_t **esp)
434: {
435: fword("decode-unit-scsi");
436: }
437:
438:
439: static void
440: ob_esp_encodeunit(__attribute__((unused)) esp_private_t **esp)
441: {
442: fword("encode-unit-scsi");
443: }
444:
445: NODE_METHODS(ob_esp) = {
446: { NULL, ob_esp_initialize },
447: { "decode-unit", ob_esp_decodeunit },
448: { "encode-unit", ob_esp_encodeunit },
449: };
450:
451: static void
452: add_alias(const char *device, const char *alias)
453: {
454: DPRINTF("add_alias dev \"%s\" = alias \"%s\"\n", device, alias);
455: push_str("/aliases");
456: fword("find-device");
457: push_str(device);
458: fword("encode-string");
459: push_str(alias);
460: fword("property");
461: }
462:
463: int
464: ob_esp_init(unsigned int slot, uint64_t base, unsigned long espoffset,
465: unsigned long dmaoffset)
466: {
467: int id, diskcount = 0, cdcount = 0, *counter_ptr;
468: char nodebuff[256], aliasbuff[256];
469: esp_private_t *esp;
470: unsigned int i;
471:
472: DPRINTF("Initializing SCSI...");
473:
474: esp = malloc(sizeof(esp_private_t));
475: if (!esp) {
476: DPRINTF("Can't allocate ESP private structure\n");
477: return -1;
478: }
479:
480: global_esp = esp;
481:
482: if (espdma_init(slot, base, dmaoffset, &esp->espdma) != 0) {
483: return -1;
484: }
485: /* Get the IO region */
486: esp->ll = (void *)ofmem_map_io(base + (uint64_t)espoffset,
487: sizeof(struct esp_regs));
488: if (esp->ll == NULL) {
489: DPRINTF("Can't map ESP registers\n");
490: return -1;
491: }
492:
493: esp->buffer = (void *)dvma_alloc(BUFSIZE, &esp->buffer_dvma);
494: if (!esp->buffer || !esp->buffer_dvma) {
495: DPRINTF("Can't get a DVMA buffer\n");
496: return -1;
497: }
498:
499: // Chip reset
500: esp->ll->regs[ESP_CMD] = ESP_CMD_RC;
501:
502: DPRINTF("ESP at 0x%lx, buffer va 0x%lx dva 0x%lx\n", (unsigned long)esp,
503: (unsigned long)esp->buffer, (unsigned long)esp->buffer_dvma);
504: DPRINTF("done\n");
505: DPRINTF("Initializing SCSI devices...");
506:
507: for (id = 0; id < 8; id++) {
508: esp->sd[id].id = id;
509: if (!inquiry(esp, &esp->sd[id])) {
510: DPRINTF("Unit %d not present\n", id);
511: continue;
512: }
513: /* Clear Unit Attention condition from reset */
514: for (i = 0; i < 5; i++) {
515: if (test_unit_ready(esp, &esp->sd[id])) {
516: break;
517: }
518: }
519: if (i == 5) {
520: DPRINTF("Unit %d present but won't become ready\n", id);
521: continue;
522: }
523: DPRINTF("Unit %d present\n", id);
524: read_capacity(esp, &esp->sd[id]);
525:
526: #ifdef CONFIG_DEBUG_ESP
527: dump_drive(&esp->sd[id]);
528: #endif
529: }
530:
531: REGISTER_NAMED_NODE(ob_esp, "/iommu/sbus/espdma/esp");
532: device_end();
533: /* set reg */
534: push_str("/iommu/sbus/espdma/esp");
535: fword("find-device");
536: PUSH(slot);
537: fword("encode-int");
538: PUSH(espoffset);
539: fword("encode-int");
540: fword("encode+");
541: PUSH(0x00000010);
542: fword("encode-int");
543: fword("encode+");
544: push_str("reg");
545: fword("property");
546:
547: PUSH(0x02625a00);
548: fword("encode-int");
549: push_str("clock-frequency");
550: fword("property");
551:
552: for (id = 0; id < 8; id++) {
553: if (!esp->sd[id].present)
554: continue;
555: push_str("/iommu/sbus/espdma/esp");
556: fword("find-device");
557: fword("new-device");
558: push_str("sd");
559: fword("device-name");
560: push_str("block");
561: fword("device-type");
562: fword("is-deblocker");
563: PUSH(id);
564: fword("encode-int");
565: PUSH(0);
566: fword("encode-int");
567: fword("encode+");
568: push_str("reg");
569: fword("property");
570: fword("finish-device");
571: snprintf(nodebuff, sizeof(nodebuff), "/iommu/sbus/espdma/esp/sd@%d,0",
572: id);
573: REGISTER_NODE_METHODS(ob_sd, nodebuff);
574: if (esp->sd[id].media == TYPE_ROM) {
575: counter_ptr = &cdcount;
576: } else {
577: counter_ptr = &diskcount;
578: }
579: if (*counter_ptr == 0) {
580: add_alias(nodebuff, esp->sd[id].media_str[0]);
581: add_alias(nodebuff, esp->sd[id].media_str[1]);
582: }
583: snprintf(aliasbuff, sizeof(aliasbuff), "%s%d",
584: esp->sd[id].media_str[0], *counter_ptr);
585: add_alias(nodebuff, aliasbuff);
586: snprintf(aliasbuff, sizeof(aliasbuff), "%s%d",
587: esp->sd[id].media_str[1], *counter_ptr);
588: add_alias(nodebuff, aliasbuff);
589: snprintf(aliasbuff, sizeof(aliasbuff), "sd(0,%d,0)", id);
590: add_alias(nodebuff, aliasbuff);
591: snprintf(aliasbuff, sizeof(aliasbuff), "sd(0,%d,0)@0,0", id);
592: add_alias(nodebuff, aliasbuff);
593: (*counter_ptr)++;
594: }
595: DPRINTF("done\n");
596:
597: return 0;
598: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.