Formatting of BD-R SRM to default size and by index

cdrskin/cdrskin_timestamp.h

@@ -1 +1 @@
-#define Cdrskin_timestamP "2008.12.09.123558"
+#define Cdrskin_timestamP "2008.12.10.092535"

libburn/async.c

@@ -412,7 +412,9 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 
 	} else if (drive->current_profile == 0x41) {
 		/* >>> BD-R SRM */
-		/* >>> check whether still unformatted */;
+
+		ok= 1;
+		/* >>> check whether already formatted */;
 
 	} else if (drive->current_profile == 0x43) {
 		ok = 1; /* BD-RE */

libburn/mmc.c

@@ -203,6 +203,10 @@ static unsigned char MMC_RESERVE_TRACK[] =
 static unsigned char MMC_READ_10[] =
 	{ 0x28, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
+/* ts A81210 : Determine the upper limit of readable data size */
+static unsigned char MMC_READ_CAPACITY[] =
+	{ 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
 
 static int mmc_function_spy_do_tell = 0;
 
@@ -1463,6 +1467,7 @@ static int mmc_read_disc_info_al(struct burn_drive *d, int *alloc_len)
 	char msg[160];
 	/* ts A70131 : had to move mmc_read_toc() to end of function */
 	int do_read_toc = 0, session_state, disc_status, len, old_alloc_len;
+	int ret;
 
 	/* ts A61020 */
 	d->start_lba = d->end_lba = -2000000000;
@@ -1473,6 +1478,9 @@ static int mmc_read_disc_info_al(struct burn_drive *d, int *alloc_len)
 	d->media_capacity_remaining = 0;
 	d->media_lba_limit = 0;
 
+	/* ts A81210 */
+	d->media_read_capacity = 0x7fffffff;
+
 	/* ts A61202 */
 	d->toc_entries = 0;
 	if (d->status == BURN_DISC_EMPTY)
@@ -1549,6 +1557,7 @@ static int mmc_read_disc_info_al(struct burn_drive *d, int *alloc_len)
 
 	switch (disc_status) {
 	case 0:
+regard_as_blank:;
 		d->toc_entries = 0;
 		d->start_lba = burn_msf_to_lba(data[17], data[18], data[19]);
 		d->end_lba = burn_msf_to_lba(data[21], data[22], data[23]);
@@ -1563,27 +1572,24 @@ static int mmc_read_disc_info_al(struct burn_drive *d, int *alloc_len)
 		break;
 	case 1:
 		d->status = BURN_DISC_APPENDABLE;
+
 	case 2:
 		if (disc_status == 2)
 			d->status = BURN_DISC_FULL;
-		do_read_toc = 1;
-		break;
-	}
 
+		/* ts A81210 */
+		ret = mmc_read_capacity(d);
+		/* Freshly formatted, unwritten BD-R pretend to be appendable
+		   but in our model they need to be regarded as blank.
+		*/
+		if (d->current_profile == 0x41 && ret > 0 &&
+		    d->status == BURN_DISC_APPENDABLE &&
+		    d->media_read_capacity == 0)
+			goto regard_as_blank;
 
-#ifdef NIX
-        /* <<< on its way out. DVD-R DL are current_is_supported_profile
-               unconditionally. Writeability is handled above now.
-        */
-	/* ts A80207 : DVD - R DL can normally be read but not be written */
-	if(d->current_profile == 0x15 && !d->current_is_supported_profile) {
-		if(d->status == BURN_DISC_APPENDABLE)
-			d->status = BURN_DISC_FULL;
-		d->erasable = 0; /* never erasable */
-		d->current_is_supported_profile = 1;
+		do_read_toc = 1;
+		break;
 	}
-#endif /* NIX */
-
 
 	if ((d->current_profile != 0 || d->status != BURN_DISC_UNREADY) 
 		&& ! d->current_is_supported_profile) {
@@ -2773,6 +2779,7 @@ int mmc_read_buffer_capacity(struct burn_drive *d)
                bit6= try to avoid lengthy media certification
                bit7= bit8 to bit15 contain the index of the format to use
                bit8-bit15 = see bit7
+              bit16= enable POW on blank BD-R
 */
 int mmc_format_unit(struct burn_drive *d, off_t size, int flag)
 {
@@ -3064,6 +3071,81 @@ no_suitable_formatting_type:;
 			c.opcode[1] |= 0x08;
 		}
 
+	} else if (d->current_profile == 0x41) {
+		/* BD-R SRM */
+
+		index = -1;
+		format_size = -1;
+		if (d->num_format_descr <= 0)
+			goto no_suitable_formatting_type;
+		if (d->format_descriptors[0].type != 0)
+			goto no_suitable_formatting_type;
+		for (i = 0; i < d->num_format_descr; i++) {
+			format_type = d->format_descriptors[i].type;
+			i_size = d->format_descriptors[i].size;
+			if (format_type != 0x00 && format_type != 0x32)
+		continue;
+			if (flag & 32) { /* No defect mgt */
+
+				/* >>> how to do this ? */
+
+				/* <<< */
+				goto no_suitable_formatting_type;
+
+			} else if(size_mode == 2) { /* max payload size */
+				/* search largest 0x32 format descriptor */
+				if(format_type != 0x32)
+		continue;
+			} else if(size_mode == 3) { /* default payload size */
+				if (format_type == 0x00) {
+					index = i;
+		break;
+				}
+		continue;
+			} else { /* defect managed format with size wish */
+				/* search for smallest 0x32 >= size */
+
+				/* >>> is the size freely adjustable ? */
+
+				if(format_type != 0x32)
+		continue;
+				if (i_size < size)
+		continue;
+				if (format_size >= 0 && i_size >= format_size)
+		continue;
+				index = i;
+				format_size = i_size;
+		continue;
+			}
+			/* common for all cases which search largest
+			   descriptors */
+			if (i_size > format_size) {
+				format_size = i_size;
+				index = i;
+			}
+		}
+		if (size_mode == 2 && index < 0 && !(flag & 32))
+			index = 0;
+		if (index < 0)
+			goto no_suitable_formatting_type;
+		format_type = d->format_descriptors[index].type;
+		if (flag & (1 << 16))
+			format_sub_type = 0; /* SRM + POW  */
+		else
+			format_sub_type = 1; /* SRM  (- POW) */
+
+		/* >>> is the size freely adjustable ? */
+
+		num_of_blocks = d->format_descriptors[index].size / 2048;
+		mmc_int_to_four_char(c.page->data + 4, num_of_blocks);
+		for (i = 0; i < 3; i++)
+			 c.page->data[9 + i] =
+				( d->format_descriptors[index].tdp >>
+					  (16 - 8 * i)) & 0xff;
+		sprintf(descr, "%s", d->current_profile_text);
+		return_immediately = 1; /* caller must do the waiting */
+		c.page->data[1] |= 0x80;  /* FOV = this flag vector is valid */
+
 	} else if (d->current_profile == 0x43) {
 		/* BD-RE */
 		index = -1;
@@ -3108,6 +3190,9 @@ no_suitable_formatting_type:;
 		continue;
 			} else { /* defect managed format with size wish */
 				/* search for smallest 0x30 >= size */
+
+				/* >>> is the size freely adjustable ? */
+
 				if(format_type != 0x30)
 		continue;
 				if (i_size < size)
@@ -3136,6 +3221,9 @@ no_suitable_formatting_type:;
 			else
 				format_sub_type = 2; /* Full certification */
 		}
+
+		/* >>> is the size freely adjustable ? */
+
 		num_of_blocks = d->format_descriptors[index].size / 2048;
 		mmc_int_to_four_char(c.page->data + 4, num_of_blocks);
 		for (i = 0; i < 3; i++)
@@ -3547,6 +3635,34 @@ int mmc_read_10(struct burn_drive *d, int start,int amount, struct buffer *buf)
 }
 
 
+/* ts A81210 : Determine the upper limit of readable data size */
+int mmc_read_capacity(struct burn_drive *d)
+{
+	struct buffer buf;
+	struct command c;
+	int alloc_len= 8;
+
+	d->media_read_capacity = 0x7fffffff;
+	if (mmc_function_spy(d, "mmc_read_capacity") <= 0)
+		return 0;
+
+	scsi_init_command(&c, MMC_READ_CAPACITY, sizeof(MMC_READ_CAPACITY));
+	c.dxfer_len = alloc_len;
+	c.retry = 1;
+	c.page = &buf;
+	c.page->bytes = 0;
+	c.page->sectors = 0;
+	c.dir = FROM_DRIVE;
+	d->issue_command(d, &c);
+	d->media_read_capacity = mmc_four_char_to_int(c.page->data);
+	if (d->media_read_capacity < 0) {
+		d->media_read_capacity = 0x7fffffff;
+		return 0;
+	}
+	return 1;
+}
+
+
 /* ts A61021 : the mmc specific part of sg.c:enumerate_common()
 */
 int mmc_setup_drive(struct burn_drive *d)
@@ -3597,6 +3713,7 @@ int mmc_setup_drive(struct burn_drive *d)
 	d->last_track_no = 1;
 	d->media_capacity_remaining = 0;
 	d->media_lba_limit = 0;
+	d->media_read_capacity = 0x7fffffff;
 	d->pessimistic_buffer_free = 0;
 	d->pbf_altered = 0;
 	d->wait_for_buffer_free = Libburn_wait_for_buffer_freE;

libburn/mmc.h

@@ -72,6 +72,8 @@ int mmc_compose_mode_page_5(struct burn_drive *d,
 int mmc_read_10(struct burn_drive *d, int start, int amount,
                 struct buffer *buf);
 
+/* ts A81210 : Determine the upper limit of readable data size */
+int mmc_read_capacity(struct burn_drive *d);
 
 
 /* mmc5r03c.pdf 4.3.4.4.1 d) "The maximum number of RZones is 2 302." */

libburn/transport.h

@@ -235,6 +235,9 @@ struct burn_drive
 	/* ts A70215 : if > 0 : first lba on media that is too high for write*/
 	int media_lba_limit;
 
+	/* ts A81210 : Upper limit of readable data size,
+	               0x7fffffff = unknown */
+	int media_read_capacity;
 
 	int toc_temp;
 	struct burn_disc *disc;	/* disc structure */