diff --git a/cli_classic.c b/cli_classic.c
index b4112fd..5dff904 100644
--- a/cli_classic.c
+++ b/cli_classic.c
@@ -51,6 +51,7 @@
 	       " -n | --noverify                    don't auto-verify\n"
 	       " -N | --noverify-all                verify included regions only (cf. -i)\n"
 	       " -l | --layout <layoutfile>         read ROM layout from <layoutfile>\n"
+	       "      --flash-name                  read out the detected flash name\n"
 	       "      --fmap                        read ROM layout from fmap embedded in ROM\n"
 	       "      --fmap-file <fmapfile>        read ROM layout from fmap in <fmapfile>\n"
 	       "      --ifd                         read layout from an Intel Firmware Descriptor\n"
@@ -101,6 +102,7 @@
 #if CONFIG_PRINT_WIKI == 1
 	int list_supported_wiki = 0;
 #endif
+	int flash_name = 0;
 	int read_it = 0, write_it = 0, erase_it = 0, verify_it = 0;
 	int dont_verify_it = 0, dont_verify_all = 0, list_supported = 0, operation_specified = 0;
 	struct flashrom_layout *layout = NULL;
@@ -110,6 +112,7 @@
 		OPTION_FMAP,
 		OPTION_FMAP_FILE,
 		OPTION_FLASH_CONTENTS,
+		OPTION_FLASH_NAME,
 	};
 	int ret = 0;
 
@@ -130,6 +133,7 @@
 		{"fmap-file",		1, NULL, OPTION_FMAP_FILE},
 		{"image",		1, NULL, 'i'},
 		{"flash-contents",	1, NULL, OPTION_FLASH_CONTENTS},
+		{"flash-name",		0, NULL, OPTION_FLASH_NAME},
 		{"list-supported",	0, NULL, 'L'},
 		{"list-supported-wiki",	0, NULL, 'z'},
 		{"programmer",		1, NULL, 'p'},
@@ -296,6 +300,14 @@
 		case OPTION_FLASH_CONTENTS:
 			referencefile = strdup(optarg);
 			break;
+		case OPTION_FLASH_NAME:
+			if (++operation_specified > 1) {
+				fprintf(stderr, "More than one operation "
+					"specified. Aborting.\n");
+				cli_classic_abort_usage();
+			}
+			flash_name = 1;
+			break;
 		case 'L':
 			if (++operation_specified > 1) {
 				fprintf(stderr, "More than one operation "
@@ -602,11 +614,22 @@
 		goto out_shutdown;
 	}
 
-	if (!(read_it | write_it | verify_it | erase_it)) {
+	if (!(read_it | write_it | verify_it | erase_it | flash_name)) {
 		msg_ginfo("No operations were specified.\n");
 		goto out_shutdown;
 	}
 
+	if (flash_name) {
+		if (fill_flash->chip->vendor && fill_flash->chip->name) {
+			printf("vendor=\"%s\" name=\"%s\"\n",
+				fill_flash->chip->vendor,
+				fill_flash->chip->name);
+		} else {
+			ret = -1;
+		}
+		goto out_shutdown;
+	}
+
 	if (layoutfile) {
 		layout = get_global_layout();
 	} else if (ifd && (flashrom_layout_read_from_ifd(&layout, fill_flash, NULL, 0) ||
diff --git a/flashrom.8.tmpl b/flashrom.8.tmpl
index 30dc97d..7002c72 100644
--- a/flashrom.8.tmpl
+++ b/flashrom.8.tmpl
@@ -44,10 +44,12 @@
 .SH NAME
 flashrom \- detect, read, write, verify and erase flash chips
 .SH SYNOPSIS
-.B flashrom \fR[\fB\-h\fR|\fB\-R\fR|\fB\-L\fR|\fB\-z\fR|\fB\-p\fR <programmername>[:<parameters>]
-            [\fB\-E\fR|\fB\-r\fR <file>|\fB\-w\fR <file>|\fB\-v\fR <file>] [\fB\-c\fR <chipname>]
-            [(\fB\-l\fR <file>|\fB\-\-ifd|\fB \-\-fmap\fR|\fB\-\-fmap-file\fR <file>) [\fB\-i\fR <image>]]
-            [\fB\-n\fR] [\fB\-N\fR] [\fB\-f\fR]]
+.B flashrom \fR[\fB\-h\fR|\fB\-R\fR|\fB\-L\fR|\fB\-z\fR|
+          \fB\-p\fR <programmername>[:<parameters>] [\fB\-c\fR <chipname>]
+            (\fB\-\-flash\-name\fR|
+             [\fB\-E\fR|\fB\-r\fR <file>|\fB\-w\fR <file>|\fB\-v\fR <file>]
+             [(\fB\-l\fR <file>|\fB\-\-ifd|\fB \-\-fmap\fR|\fB\-\-fmap-file\fR <file>) [\fB\-i\fR <image>]]
+             [\fB\-n\fR] [\fB\-N\fR] [\fB\-f\fR])]
          [\fB\-V\fR[\fBV\fR[\fBV\fR]]] [\fB-o\fR <logfile>]
 .SH DESCRIPTION
 .B flashrom
@@ -242,6 +244,9 @@
 .B <imagename>
 from flash layout.
 .TP
+.B "\-\-flash\-name"
+Prints out the detected flash chips name.
+.TP
 .B "\-L, \-\-list\-supported"
 List the flash chips, chipsets, mainboards, and external programmers
 (including PCI, USB, parallel port, and serial port based devices)
@@ -1335,6 +1340,8 @@
 .br
 Dominik Geyer
 .br
+Edward O'Callaghan
+.br
 Eric Biederman
 .br
 Giampiero Giancipoli
