Skip to contentSkip to conversation

Nexus One Support

PATCH In review Daniel Walker 17 participants 69 messages Jan 20, 2011 – Feb 7, 2011

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover Nexus One Support

This series adds basic Nexus One support which includes a booting kernel, and functional MMC .

Most people won't be able to use this yet unfortunately because you need a serial cable to get any output. However, it's a start.

Brian Swetland (1):
[ARM] msm: qsd8k memory base is at 0x20000000

Daniel Walker (6):
msm: qsd8x50: add uart platform data
msm: qsd8x50: add acpuclock code
msm: mahimahi: add mahimahi board file
msm: mahimahi: add in mmc support code
msm: mahimahi: add gpio pin muxing code
msm: mahimahi: initialize mmc at start up

 arch/arm/mach-msm/Kconfig              |    8 +-
 arch/arm/mach-msm/Makefile             |    5 +-
 arch/arm/mach-msm/Makefile.boot        |    5 +
 arch/arm/mach-msm/acpuclock-qsd8x50.c  |  457 ++++++++++++++++++++++++++++++++
 arch/arm/mach-msm/board-mahimahi-mmc.c |  238 +++++++++++++++++
 arch/arm/mach-msm/board-mahimahi.c     |   52 +++-
 arch/arm/mach-msm/board-mahimahi.h     |  147 ++++++++++
 arch/arm/mach-msm/devices-qsd8x50.c    |   42 +++
 arch/arm/mach-msm/include/mach/board.h |    1 +
 9 files changed, 942 insertions(+), 13 deletions(-)
 create mode 100644 arch/arm/mach-msm/acpuclock-qsd8x50.c
 create mode 100644 arch/arm/mach-msm/board-mahimahi-mmc.c
 create mode 100644 arch/arm/mach-msm/board-mahimahi.h
Signature · 2 lines
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#1 lore raw

PATCH 1/7 msm: qsd8x50: add uart platform data

This enables the uart for QSD8x50.

---
 arch/arm/mach-msm/devices-qsd8x50.c |   42 +++++++++++++++++++++++++++++++++++
 1 files changed, 42 insertions(+), 0 deletions(-)
arch/arm/mach-msm/devices-qsd8x50.c +42 -0
index b1a8f0f..24b2051 100644
@@ -28,6 +28,32 @@
 
 #include <mach/mmc.h>
 
+static struct resource resources_uart1[] = {
+	{
+		.start	= INT_UART1,
+		.end	= INT_UART1,
+		.flags	= IORESOURCE_IRQ,
+	},
+	{
+		.start	= MSM_UART1_PHYS,
+		.end	= MSM_UART1_PHYS + MSM_UART1_SIZE - 1,
+		.flags	= IORESOURCE_MEM,
+	},
+};
+
+static struct resource resources_uart2[] = {
+	{
+		.start	= INT_UART2,
+		.end	= INT_UART2,
+		.flags	= IORESOURCE_IRQ,
+	},
+	{
+		.start	= MSM_UART2_PHYS,
+		.end	= MSM_UART2_PHYS + MSM_UART2_SIZE - 1,
+		.flags	= IORESOURCE_MEM,
+	},
+};
+
 static struct resource resources_uart3[] = {
 	{
 		.start	= INT_UART3,
@@ -41,6 +67,20 @@ static struct resource resources_uart3[] = {
 	},
 };
 
+struct platform_device msm_device_uart1 = {
+	.name	= "msm_serial",
+	.id	= 0,
+	.num_resources	= ARRAY_SIZE(resources_uart1),
+	.resource	= resources_uart1,
+};
+
+struct platform_device msm_device_uart2 = {
+	.name	= "msm_serial",
+	.id	= 1,
+	.num_resources	= ARRAY_SIZE(resources_uart2),
+	.resource	= resources_uart2,
+};
+
 struct platform_device msm_device_uart3 = {
 	.name	= "msm_serial",
 	.id	= 2,
@@ -345,6 +385,8 @@ struct clk msm_clocks_8x50[] = {
 	CLK_PCOM("tsif_ref_clk",	TSIF_REF_CLK,	NULL, 0),
 	CLK_PCOM("tv_dac_clk",	TV_DAC_CLK,	NULL, 0),
 	CLK_PCOM("tv_enc_clk",	TV_ENC_CLK,	NULL, 0),
+	CLK_PCOM("uart_clk",	UART1_CLK,	&msm_device_uart1.dev, OFF),
+	CLK_PCOM("uart_clk",	UART2_CLK,	&msm_device_uart2.dev, OFF),
 	CLK_PCOM("uart_clk",	UART3_CLK,	&msm_device_uart3.dev, OFF),
 	CLK_PCOM("usb_hs_clk",	USB_HS_CLK,	NULL, OFF),
 	CLK_PCOM("usb_hs_pclk",	USB_HS_P_CLK,	NULL, OFF),
Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#2 lore raw

PATCH 2/7 msm: qsd8k memory base is at 0x20000000

In reply to Daniel Walker

From: Brian Swetland <[email protected]>

The memory layout is effective as of AMSS 3170+.

---
 arch/arm/mach-msm/Makefile.boot |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)
arch/arm/mach-msm/Makefile.boot +5 -0
index 24dfbf8..3266727 100644
@@ -1,3 +1,8 @@
   zreladdr-y		:= 0x10008000
 params_phys-y		:= 0x10000100
 initrd_phys-y		:= 0x10800000
+
+# for now, override for QSD8x50
+  zreladdr-$(CONFIG_ARCH_QSD8X50)		:= 0x20008000
+params_phys-$(CONFIG_ARCH_QSD8X50)		:= 0x20000100
+initrd_phys-$(CONFIG_ARCH_QSD8X50)		:= 0x21000000
Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#3 lore raw

PATCH 3/7 msm: qsd8x50: add acpuclock code

In reply to Daniel Walker

This adds acpuclock-qsd8x50.c from Google. This provides control over the cpu frequency for qsd8x50 SoCs.

---
 arch/arm/mach-msm/Makefile             |    3 +-
 arch/arm/mach-msm/acpuclock-qsd8x50.c  |  457 ++++++++++++++++++++++++++++++++
 arch/arm/mach-msm/board-mahimahi.c     |   24 ++
 arch/arm/mach-msm/include/mach/board.h |    1 +
 4 files changed, 484 insertions(+), 1 deletions(-)
 create mode 100644 arch/arm/mach-msm/acpuclock-qsd8x50.c
arch/arm/mach-msm/Makefile +2 -1
index 94195c1..9fd3a35 100644
@@ -1,6 +1,5 @@
 obj-y += io.o idle.o timer.o
 ifndef CONFIG_ARCH_MSM8X60
-obj-y += acpuclock-arm11.o
 obj-y += dma.o
 endif
 
@@ -11,6 +10,8 @@ ifndef CONFIG_ARCH_MSM8X60
 obj-y += irq.o
 endif
 endif
+obj-$(CONFIG_ARCH_MSM_ARM11) += acpuclock-arm11.o
+obj-$(CONFIG_ARCH_QSD8X50) += acpuclock-qsd8x50.o
 
 obj-$(CONFIG_ARCH_MSM8X60) += clock-dummy.o iommu.o iommu_dev.o devices-msm8x60-iommu.o
 obj-$(CONFIG_MSM_PROC_COMM) += proc_comm.o clock-pcom.o vreg.o
arch/arm/mach-msm/acpuclock-qsd8x50.c new file +457 -0

457 lines not on this page · raw message

arch/arm/mach-msm/board-mahimahi.c +24 -0
index ef3ebf2..aedb136 100644
@@ -48,8 +48,32 @@ static struct platform_device *devices[] __initdata = {
 	&msm_device_nand,
 };
 
+static struct msm_acpu_clock_platform_data mahimahi_clock_data = {
+	.acpu_switch_time_us	= 20,
+	.max_speed_delta_khz	= 256000,
+	.vdd_switch_time_us	= 62,
+	.power_collapse_khz	= 245000,
+	.wait_for_irq_khz	= 245000,
+	.mpll_khz		= 245000
+};
+
+static struct msm_acpu_clock_platform_data mahimahi_cdma_clock_data = {
+	.acpu_switch_time_us	= 20,
+	.max_speed_delta_khz	= 256000,
+	.vdd_switch_time_us	= 62,
+	.power_collapse_khz	= 235930,
+	.wait_for_irq_khz	= 235930,
+	.mpll_khz		= 235930
+};
+
+
 static void __init mahimahi_init(void)
 {
+	if (is_cdma_version(system_rev))
+		msm_acpu_clock_init(&mahimahi_cdma_clock_data);
+	else
+		msm_acpu_clock_init(&mahimahi_clock_data);
+
 	platform_add_devices(devices, ARRAY_SIZE(devices));
 }
 
arch/arm/mach-msm/include/mach/board.h +1 -0
index 6abf4a6..44efaf5 100644
@@ -27,6 +27,7 @@ struct msm_acpu_clock_platform_data
 	uint32_t acpu_switch_time_us;
 	uint32_t max_speed_delta_khz;
 	uint32_t vdd_switch_time_us;
+	unsigned long mpll_khz;
 	unsigned long power_collapse_khz;
 	unsigned long wait_for_irq_khz;
 };
Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#4 lore raw

PATCH 4/7 msm: mahimahi: add mahimahi board file

In reply to Daniel Walker

This adds basic boot support for Nexus One (aka Mahimahi).

This code was taken from Google's tree, with slight modifications and clean up.

---
 arch/arm/mach-msm/Kconfig          |    8 ++-
 arch/arm/mach-msm/Makefile         |    1 +
 arch/arm/mach-msm/board-mahimahi.c |   20 ++---
 arch/arm/mach-msm/board-mahimahi.h |  147 ++++++++++++++++++++++++++++++++++++
 4 files changed, 164 insertions(+), 12 deletions(-)
 create mode 100644 arch/arm/mach-msm/board-mahimahi.h
arch/arm/mach-msm/Kconfig +7 -1
index 5d3d9ad..0bb8173 100644
@@ -27,7 +27,7 @@ config ARCH_MSM7X30
 
 config ARCH_QSD8X50
 	bool "QSD8X50"
-	select MACH_QSD8X50_SURF if !MACH_QSD8X50A_ST1_5
+	select MACH_QSD8X50_SURF if (!MACH_QSD8X50A_ST1_5 && !MACH_MAHIMAHI)
 	select ARCH_MSM_SCORPION
 	select MSM_SMD
 	select MSM_VIC
@@ -88,6 +88,12 @@ config MACH_MSM7X30_SURF
 	help
 	  Support for the Qualcomm MSM7x30 SURF eval board.
 
+config MACH_MAHIMAHI
+        depends on ARCH_QSD8X50
+        bool "HTC Passion/Nexus One"
+        help
+          Select this to support an HTC Passion/Nexus One phone.
+
 config MACH_QSD8X50_SURF
 	depends on ARCH_QSD8X50
 	bool "QSD8x50 SURF"
arch/arm/mach-msm/Makefile +1 -0
index 9fd3a35..a0ebce4 100644
@@ -30,6 +30,7 @@ obj-$(CONFIG_MACH_HALIBUT) += board-halibut.o devices-msm7x00.o
 obj-$(CONFIG_ARCH_MSM7X30) += board-msm7x30.o devices-msm7x30.o
 obj-$(CONFIG_ARCH_QSD8X50) += board-qsd8x50.o devices-qsd8x50.o
 obj-$(CONFIG_ARCH_MSM8X60) += board-msm8x60.o
+obj-$(CONFIG_MACH_MAHIMAHI) += board-mahimahi.o
 
 obj-$(CONFIG_ARCH_MSM7X30) += gpiomux-7x30.o gpiomux-v1.o gpiomux.o
 obj-$(CONFIG_ARCH_QSD8X50) += gpiomux-8x50.o gpiomux-v1.o gpiomux.o
arch/arm/mach-msm/board-mahimahi.c +9 -11
index aedb136..c1745c7 100644
@@ -41,11 +41,7 @@ static uint debug_uart;
 module_param_named(debug_uart, debug_uart, uint, 0);
 
 static struct platform_device *devices[] __initdata = {
-#if !defined(CONFIG_MSM_SERIAL_DEBUGGER)
 	&msm_device_uart1,
-#endif
-	&msm_device_uart_dm1,
-	&msm_device_nand,
 };
 
 static struct msm_acpu_clock_platform_data mahimahi_clock_data = {
@@ -82,28 +78,30 @@ static void __init mahimahi_fixup(struct machine_desc *desc, struct tag *tags,
 {
 	mi->nr_banks = 2;
 	mi->bank[0].start = PHYS_OFFSET;
-	mi->bank[0].node = PHYS_TO_NID(PHYS_OFFSET);
 	mi->bank[0].size = (219*1024*1024);
 	mi->bank[1].start = MSM_HIGHMEM_BASE;
-	mi->bank[1].node = PHYS_TO_NID(MSM_HIGHMEM_BASE);
 	mi->bank[1].size = MSM_HIGHMEM_SIZE;
 }
 
 static void __init mahimahi_map_io(void)
 {
-	msm_map_common_io();
-	msm_clock_init();
+	msm_map_qsd8x50_io();
+	msm_clock_init(msm_clocks_8x50, msm_num_clocks_8x50);
+}
+
+static void __init mahimahi_init_irq(void)
+{
+	msm_init_irq();
+	msm_init_sirc();
 }
 
 extern struct sys_timer msm_timer;
 
 MACHINE_START(MAHIMAHI, "mahimahi")
-#ifdef CONFIG_MSM_DEBUG_UART
-#endif
 	.boot_params	= 0x20000100,
 	.fixup		= mahimahi_fixup,
 	.map_io		= mahimahi_map_io,
-	.init_irq	= msm_init_irq,
+	.init_irq	= mahimahi_init_irq,
 	.init_machine	= mahimahi_init,
 	.timer		= &msm_timer,
 MACHINE_END
arch/arm/mach-msm/board-mahimahi.h new file +147 -0

147 lines not on this page · raw message

Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#5 lore raw

PATCH 5/7 msm: mahimahi: add in mmc support code

In reply to Daniel Walker

This adds code to enable MMC on mahimahi.

This code was taken from Google's tree, with slight modifications and clean up.

---
 arch/arm/mach-msm/Makefile             |    1 +
 arch/arm/mach-msm/board-mahimahi-mmc.c |  206 ++++++++++++++++++++++++++++++++
 2 files changed, 207 insertions(+), 0 deletions(-)
 create mode 100644 arch/arm/mach-msm/board-mahimahi-mmc.c
arch/arm/mach-msm/Makefile +1 -0
index a0ebce4..5012c37 100644
@@ -31,6 +31,7 @@ obj-$(CONFIG_ARCH_MSM7X30) += board-msm7x30.o devices-msm7x30.o
 obj-$(CONFIG_ARCH_QSD8X50) += board-qsd8x50.o devices-qsd8x50.o
 obj-$(CONFIG_ARCH_MSM8X60) += board-msm8x60.o
 obj-$(CONFIG_MACH_MAHIMAHI) += board-mahimahi.o
+obj-$(CONFIG_MACH_MAHIMAHI) += board-mahimahi-mmc.o
 
 obj-$(CONFIG_ARCH_MSM7X30) += gpiomux-7x30.o gpiomux-v1.o gpiomux.o
 obj-$(CONFIG_ARCH_QSD8X50) += gpiomux-8x50.o gpiomux-v1.o gpiomux.o
arch/arm/mach-msm/board-mahimahi-mmc.c new file +206 -0

206 lines not on this page · raw message

Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#6 lore raw

PATCH 6/7 msm: mahimahi: add gpio pin muxing code

In reply to Daniel Walker

Add in old style pin muxing code. This code is from Google's tree. However, the other way to do this is to use gpiomux, but it's currently not mature enough to have on/off configurations.

This code was taken from Google's tree, with slight modifications and clean up.

---
 arch/arm/mach-msm/board-mahimahi-mmc.c |   32 ++++++++++++++++++++++++++++++++
 1 files changed, 32 insertions(+), 0 deletions(-)
arch/arm/mach-msm/board-mahimahi-mmc.c +32 -0
index 991818e..13e45d0 100644
@@ -54,6 +54,34 @@ static struct msm_mmc_gpio sdc1_gpio_cfg[] = {
 	{67, "sdc1_dat_0"},
 };
 
+static void config_gpio_table(uint32_t *table, int len)
+{
+	int n;
+	unsigned id;
+	for (n = 0; n < len; n++) {
+		id = table[n];
+		msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
+	}
+}
+
+static uint32_t sdcard_on_gpio_table[] = {
+	PCOM_GPIO_CFG(62, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_8MA), /* CLK */
+	PCOM_GPIO_CFG(63, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), /* CMD */
+	PCOM_GPIO_CFG(64, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_4MA), /* DAT3 */
+	PCOM_GPIO_CFG(65, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_4MA), /* DAT2 */
+	PCOM_GPIO_CFG(66, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_4MA), /* DAT1 */
+	PCOM_GPIO_CFG(67, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_4MA), /* DAT0 */
+};
+
+static uint32_t sdcard_off_gpio_table[] = {
+	PCOM_GPIO_CFG(62, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), /* CLK */
+	PCOM_GPIO_CFG(63, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), /* CMD */
+	PCOM_GPIO_CFG(64, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), /* DAT3 */
+	PCOM_GPIO_CFG(65, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), /* DAT2 */
+	PCOM_GPIO_CFG(66, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), /* DAT1 */
+	PCOM_GPIO_CFG(67, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), /* DAT0 */
+};
+
 static struct vreg	*sdslot_vreg;
 static uint32_t		sdslot_vdd = 0xffffffff;
 static uint32_t		sdslot_vreg_enabled;
@@ -86,6 +114,8 @@ static uint32_t mahimahi_sdslot_switchvdd(struct device *dev, unsigned int vdd)
 	sdslot_vdd = vdd;
 
 	if (vdd == 0) {
+		config_gpio_table(sdcard_off_gpio_table,
+				  ARRAY_SIZE(sdcard_off_gpio_table));
 		vreg_disable(sdslot_vreg);
 		sdslot_vreg_enabled = 0;
 		return 0;
@@ -95,6 +125,8 @@ static uint32_t mahimahi_sdslot_switchvdd(struct device *dev, unsigned int vdd)
 		ret = vreg_enable(sdslot_vreg);
 		if (ret)
 			pr_err("Error enabling vreg (%d)\n", ret);
+		config_gpio_table(sdcard_on_gpio_table,
+				  ARRAY_SIZE(sdcard_on_gpio_table));
 		sdslot_vreg_enabled = 1;
 	}
 
Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#7 lore raw

PATCH 7/7 msm: mahimahi: initialize mmc at start up

In reply to Daniel Walker

MMC should fully function at this point. This adds in the calls to start the initialization.

---
 arch/arm/mach-msm/board-mahimahi.c |    8 ++++++++
 1 files changed, 8 insertions(+), 0 deletions(-)
arch/arm/mach-msm/board-mahimahi.c +8 -0
index c1745c7..e7c70ca 100644
@@ -38,6 +38,8 @@
 
 static uint debug_uart;
 
+int mahimahi_init_mmc(unsigned int sys_rev, unsigned debug_uart);
+
 module_param_named(debug_uart, debug_uart, uint, 0);
 
 static struct platform_device *devices[] __initdata = {
@@ -65,11 +67,17 @@ static struct msm_acpu_clock_platform_data mahimahi_cdma_clock_data = {
 
 static void __init mahimahi_init(void)
 {
+	int ret;
+
 	if (is_cdma_version(system_rev))
 		msm_acpu_clock_init(&mahimahi_cdma_clock_data);
 	else
 		msm_acpu_clock_init(&mahimahi_clock_data);
 
+	ret = mahimahi_init_mmc(system_rev, debug_uart);
+	if (ret != 0)
+		pr_crit("%s: Unable to initialize MMC\n", __func__);
+
 	platform_add_devices(devices, ARRAY_SIZE(devices));
 }
 
Signature · 5 lines
1.7.0.4

-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
#8 lore raw
In reply to Daniel Walker

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

--Dima

Quoted 40 lines · Daniel Walker

This series adds basic Nexus One support which includes a booting kernel, and functional MMC .

Most people won't be able to use this yet unfortunately because you need a serial cable to get any output. However, it's a start.

Brian Swetland (1):
?[ARM] msm: qsd8k memory base is at 0x20000000

Daniel Walker (6):
?msm: qsd8x50: add uart platform data
?msm: qsd8x50: add acpuclock code
?msm: mahimahi: add mahimahi board file
?msm: mahimahi: add in mmc support code
?msm: mahimahi: add gpio pin muxing code
?msm: mahimahi: initialize mmc at start up

?arch/arm/mach-msm/Kconfig ? ? ? ? ? ? ?| ? ?8 +-
?arch/arm/mach-msm/Makefile ? ? ? ? ? ? | ? ?5 +-
?arch/arm/mach-msm/Makefile.boot ? ? ? ?| ? ?5 +
?arch/arm/mach-msm/acpuclock-qsd8x50.c ?| ?457 ++++++++++++++++++++++++++++++++
?arch/arm/mach-msm/board-mahimahi-mmc.c | ?238 +++++++++++++++++
?arch/arm/mach-msm/board-mahimahi.c ? ? | ? 52 +++-
?arch/arm/mach-msm/board-mahimahi.h ? ? | ?147 ++++++++++
?arch/arm/mach-msm/devices-qsd8x50.c ? ?| ? 42 +++
?arch/arm/mach-msm/include/mach/board.h | ? ?1 +

?9 files changed, 942 insertions(+), 13 deletions(-) ?create mode 100644 arch/arm/mach-msm/acpuclock-qsd8x50.c ?create mode 100644 arch/arm/mach-msm/board-mahimahi-mmc.c ?create mode 100644 arch/arm/mach-msm/board-mahimahi.h

--
Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum. --
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo at vger.kernel.org
More majordomo info at ?http://vger.kernel.org/majordomo-info.html Please read the FAQ at ?http://www.tux.org/lkml/

#9 lore raw
Quoted 2 lines · Dima Zavin

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

In the commit text.. The author field is used to denote who authored the commit, which in this case is me. The code holds Google copyrights which means all or parts are actually owned by Google ..

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#10 lore raw
Quoted 5 lines · Daniel Walker
Quoted 2 lines · Dima Zavin

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

In the commit text.. The author field is used to denote who authored the commit, which in this case is me.

You have that wrong.
Author and Committer are different git fields.

http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

* an author: The name of the person responsible for this change, together with its date.
* a committer: The name of the person who actually created the commit, with the date it was done. This may be different from the author, for example, if the author was someone who wrote a patch and emailed it to the person who used it to create the commit.

#11 lore raw
Quoted 12 lines · Joe Perches
Quoted 5 lines · Daniel Walker
Quoted 2 lines · Dima Zavin

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

In the commit text.. The author field is used to denote who authored the commit, which in this case is me.

You have that wrong.
Author and Committer are different git fields.

http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

Quoted 7 lines

* an author: The name of the person responsible for this change, together with its date.
* a committer: The name of the person who actually created the commit, with the date it was done. This may be different from the author, for example, if the author was someone who wrote a patch and emailed it to the person who used it to create the commit.

I'm not even sure how to make these different, but in this case it doesn't matter because the "committer" as you defined it above is more than one person ..

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#12 lore raw

You did not write ANY code for the mahimahi (Nexus One) board. You took patches from the android.git.kernel.org git server, squashed some together, and then slapped your name on them as the author. I appreciate your effort to send this code upstream and do whatever minor cleanups, but I still maintain that you are not the author of this code.

--Dima

Quoted 35 lines · Daniel Walker
Quoted 12 lines · Joe Perches
Quoted 5 lines · Daniel Walker
Quoted 2 lines · Dima Zavin

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

In the commit text.. The author field is used to denote who authored the commit, which in this case is me.

You have that wrong.
Author and Committer are different git fields.

http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

Quoted 7 lines

? ? ? * an author: The name of the person responsible for this change, ? ? ? ? together with its date.
? ? ? * a committer: The name of the person who actually created the ? ? ? ? commit, with the date it was done. This may be different from ? ? ? ? the author, for example, if the author was someone who wrote a ? ? ? ? patch and emailed it to the person who used it to create the ? ? ? ? commit.

I'm not even sure how to make these different, but in this case it doesn't matter because the "committer" as you defined it above is more than one person ..

Daniel

--
Sent by an consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.

#13 lore raw
Quoted 6 lines · Dima Zavin

You did not write ANY code for the mahimahi (Nexus One) board. You took patches from the android.git.kernel.org git server, squashed some together, and then slapped your name on them as the author. I appreciate your effort to send this code upstream and do whatever minor cleanups, but I still maintain that you are not the author of this code.

I'm not claiming I wrote it all, clearly the copyrights indicate that.

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#14 lore raw
In reply to Daniel Walker
Quoted 18 lines · Daniel Walker
Quoted 10 lines · Joe Perches
Quoted 5 lines · Daniel Walker
Quoted 2 lines · Dima Zavin

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

In the commit text.. The author field is used to denote who authored the commit, which in this case is me.

You have that wrong.
Author and Committer are different git fields.
http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

Quoted 7 lines

* an author: The name of the person responsible for this change, together with its date.
* a committer: The name of the person who actually created the commit, with the date it was done. This may be different from the author, for example, if the author was someone who wrote a patch and emailed it to the person who used it to create the commit.

Quoted 3 lines

I'm not even sure how to make these different, but in this case it doesn't matter because the "committer" as you defined it above is more than one person ..

Not really, no.

The authors may be different, but the first git committer of the patch is different.

The committer is the person that does a git commit either directly with git commit or git am.

If a git tree is pulled by someone else, the initial committer name remains on the commit.

You should keep the original patch author names and add your own "Signed-off-by:" and not claim authorship of the patches themselves.

cheers, Joe

#15 lore raw
Quoted 11 lines · Joe Perches

The authors may be different, but the first git committer of the patch is different.

The committer is the person that does a git commit either directly with git commit or git am.

You should keep the original patch author names and add your own "Signed-off-by:" and not claim authorship of the patches themselves.

For example, many people send me patches for the ext4 tree.

Even if I get the patches from somewhere else, say the SuSE RPM, I will try to determine the author, and use that as the author field in the patches. If I put a

From: The Original Author <[email protected]>

in the patch before I suck it in using git am, it will use the original author in the Author field. I will add my Signed-off-by, preserving the other Signed-off-by's, and my name will appear in the Committer field, which is as it should be.

-- Ted

#16 lore raw
In reply to Joe Perches
Quoted 31 lines · Joe Perches
Quoted 18 lines · Daniel Walker
Quoted 10 lines · Joe Perches
Quoted 5 lines · Daniel Walker
Quoted 2 lines · Dima Zavin

You are not the author of any of these patches. Where are the author attributions for the team that actually wrote this code?

In the commit text.. The author field is used to denote who authored the commit, which in this case is me.

You have that wrong.
Author and Committer are different git fields.
http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

Quoted 7 lines

* an author: The name of the person responsible for this change, together with its date.
* a committer: The name of the person who actually created the commit, with the date it was done. This may be different from the author, for example, if the author was someone who wrote a patch and emailed it to the person who used it to create the commit.

Quoted 3 lines

I'm not even sure how to make these different, but in this case it doesn't matter because the "committer" as you defined it above is more than one person ..

Not really, no.

The authors may be different, but the first git committer of the patch is different.

The committer is the person that does a git commit either directly with git commit or git am.

Quoted 6 lines

If a git tree is pulled by someone else, the initial committer name remains on the commit.

You should keep the original patch author names and add your own "Signed-off-by:" and not claim authorship of the patches themselves.

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#17 lore raw
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

Signature · 1 line
Jesse Barnes, Intel Open Source Technology Center
#18 lore raw
Quoted 20 lines · Jesse Barnes
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

I did create these commits. Do you think someone else created the commits? There is no commit forwarding happening here.

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#19 lore raw
Quoted 2 lines · Daniel Walker

I did create these commits. Do you think someone else created the commits? There is no commit forwarding happening here.

Creating a commit is easy. I think for cases like this it's a good idea to at least write down a "Based on patches from ..." in the commit message, and preferably also how it relates to their patches. E.g. dropped android local crap, ported to $FOO kernel ABI, or just rolled up totally confused local repository history.

#20 lore raw
In reply to Jesse Barnes
Quoted 20 lines · On Fri, 21 Jan 2011 09:48:27 -0800 Jesse Barnes <[email protected]>…
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

That said, if you did significant work on these before committing them, then you're right and I'm wrong. It *is* fairly common for committers to change things; and if the changes are significant enough, they claim authorship and note the original author in the changelog.

So if that's the case here, I apologize, but I didn't see that explained in any part of the thread I read.

Signature · 1 line
Jesse Barnes, Intel Open Source Technology Center
#21 lore raw
Quoted 30 lines · Jesse Barnes
Quoted 20 lines · On Fri, 21 Jan 2011 09:48:27 -0800 Jesse Barnes <[email protected]>…
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

Quoted 7 lines

That said, if you did significant work on these before committing them, then you're right and I'm wrong. It *is* fairly common for committers to change things; and if the changes are significant enough, they claim authorship and note the original author in the changelog.

So if that's the case here, I apologize, but I didn't see that explained in any part of the thread I read.

I did a significant amount of work to create the commits and series. I'm sorry if that's not clear, but it is in fact true.

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#22 lore raw
Quoted 36 lines · On Fri, 21 Jan 2011 10:00:28 -0800 Daniel Walker <[email protected]> wrote:
Quoted 35 lines · Jesse Barnes
Quoted 20 lines · On Fri, 21 Jan 2011 09:48:27 -0800 Jesse Barnes <[email protected]>…
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

That said, if you did significant work on these before committing them, then you're right and I'm wrong. It *is* fairly common for committers to change things; and if the changes are significant enough, they claim authorship and note the original author in the changelog.

Quoted 5 lines
Quoted 2 lines

So if that's the case here, I apologize, but I didn't see that explained in any part of the thread I read.

I did a significant amount of work to create the commits and series. I'm sorry if that's not clear, but it is in fact true.

Changes to the code or just reordering and merging commits? If the former, then I think Christoph's comment applies, if the latter, I think preserving authorship is still the right thing to do.

Signature · 1 line
Jesse Barnes, Intel Open Source Technology Center
#23 lore raw
Quoted 42 lines · Jesse Barnes
Quoted 39 lines · On Fri, 21 Jan 2011 10:00:28 -0800 Daniel Walker <[email protected]> wrote:
Quoted 37 lines · Jesse Barnes
Quoted 20 lines · On Fri, 21 Jan 2011 09:48:27 -0800 Jesse Barnes <[email protected]>…
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

That said, if you did significant work on these before committing them, then you're right and I'm wrong. It *is* fairly common for committers to change things; and if the changes are significant enough, they claim authorship and note the original author in the changelog.

So if that's the case here, I apologize, but I didn't see that explained in any part of the thread I read.

Quoted 6 lines
Quoted 2 lines

I did a significant amount of work to create the commits and series. I'm sorry if that's not clear, but it is in fact true.

Changes to the code or just reordering and merging commits? If the former, then I think Christoph's comment applies, if the latter, I think preserving authorship is still the right thing to do.

I changed both, switching to new kernel API's, clean ups, finding a minimum set of code for this support, and debugging that and fixing defects in the code. This wasn't a trivial amount of work to create the series and commits.

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#24 lore raw
Quoted 46 lines · On Fri, 21 Jan 2011 10:18:02 -0800 Daniel Walker <[email protected]> wrote:
Quoted 45 lines · Jesse Barnes
Quoted 41 lines · On Fri, 21 Jan 2011 10:00:28 -0800 Daniel Walker <[email protected]> wrote:
Quoted 30 lines · Jesse Barnes
Quoted 20 lines · On Fri, 21 Jan 2011 09:48:27 -0800 Jesse Barnes <[email protected]>…
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

Quoted 7 lines

That said, if you did significant work on these before committing them, then you're right and I'm wrong. It *is* fairly common for committers to change things; and if the changes are significant enough, they claim authorship and note the original author in the changelog.

So if that's the case here, I apologize, but I didn't see that explained in any part of the thread I read.

I did a significant amount of work to create the commits and series. I'm sorry if that's not clear, but it is in fact true.

Quoted 8 lines
Quoted 3 lines

Changes to the code or just reordering and merging commits? If the former, then I think Christoph's comment applies, if the latter, I think preserving authorship is still the right thing to do.

I changed both, switching to new kernel API's, clean ups, finding a minimum set of code for this support, and debugging that and fixing defects in the code. This wasn't a trivial amount of work to create the series and commits.

Ok, then I'm sorry for jumping the gun. The changelogs made the changes sound more trivial ("slight modifications and cleanup"); and those would only justify a small [] text near the s-o-b lines. But if they're larger, maybe you should expand on the text and include the original authorship like Christoph suggested (or use the original author for patches where the changes really were trivial).

Signature · 1 line
Jesse Barnes, Intel Open Source Technology Center
#25 lore raw
Quoted 6 lines · Jesse Barnes

Ok, then I'm sorry for jumping the gun. The changelogs made the changes sound more trivial ("slight modifications and cleanup"); and those would only justify a small [] text near the s-o-b lines. But if they're larger, maybe you should expand on the text and include the original authorship like Christoph suggested (or use the original author for patches where the changes really were trivial).

yeah, I didn't really think about that line when I wrote it.. It should just says "Base on code from Google." I was just trying to give them some credit.

I've done changes like your suggesting (923a081c72fa2dccb7ea7070bd8e0f4dc99ceff8) so I'm not a novice to this.

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#26 lore raw
In reply to Daniel Walker

Really though? Let's look at one of them:

[PATCH 3/7] msm: qsd8x50: add acpuclock code

Please tell me the amount of time it took you to "debug and fix defects in the code" from the following:
http://android.git.kernel.org/?p=kernel/experimental.git;a=blob;f=arch/arm/mach-msm/acpuclock-qsd8x50.c;h=691acdeaad74c2f29927308b8110af7d4dd5070b;hb=refs/heads/android-msm-2.6.37-wip

That is basically a squash of 3 commits (one of which was another squash of ~20 commits during a cleanup which has all the attributions in the squash). This file's main authors was Brian, Arve, and myself, with some contributions from Mike, Iliyan, and Haley from HTC. Doing a quick-and-dirty grep through the history, the contributions break down as:
2 Arve Hj?nnev?g <[email protected]>
6 Brian Swetland <[email protected]>
14 Dima Zavin <[email protected]>
2 Haley Teng <[email protected]>
1 Iliyan Malchev <[email protected]>
5 Mike Chan <[email protected]>

Your commit is a:
git checkout <branch> -- <file> ; git add ; git commit;

--Dima

Quoted 64 lines · Daniel Walker
Quoted 42 lines · Jesse Barnes
Quoted 39 lines · On Fri, 21 Jan 2011 10:00:28 -0800 Daniel Walker <[email protected]> wrote:
Quoted 37 lines · Jesse Barnes
Quoted 20 lines · On Fri, 21 Jan 2011 09:48:27 -0800 Jesse Barnes <[email protected]>…
Quoted 8 lines · On Fri, 21 Jan 2011 07:46:41 -0800 Daniel Walker <[email protected]> wrote:

This isn't what's happening tho. In maintainer land if someone forwards you a patch then you leave the original author on the patch. They wrote the patch and your just forwarding it on up the ladder. This isn't the case with these patches.. I crafted each of the commit I have authorship on, no one forwarded those commits to me. I'm not taking authorship credit for any thing I didn't create, although I an giving credit to the place which gave me the raw material which was Google. From my experience this is how it's done in Linux ..

I don't know why you're even trying to defend this, just admit you were wrong and move on.

Trying to claim the author field for these patches for yourself is both misleading and vain. ?You did not write the code and are therefore not the author, trying to conflate the author and commit fields in this way is so misguided I thought you must be trolling when I first saw this thread.

Quoted 6 lines

This is not "how it's done in Linux" at all. ?In this case you're trying to act like a maintainer by collecting patches and forwarding them upstream, so you need to preserve authorship and the s-o-b chain. If you want to take responsibility for the code going forward, great, but don't pollute the logs with bogus author fields that imply you wrote the stuff in the first place.

That said, if you did significant work on these before committing them, then you're right and I'm wrong. ?It *is* fairly common for committers to change things; and if the changes are significant enough, they claim authorship and note the original author in the changelog.

So if that's the case here, I apologize, but I didn't see that explained in any part of the thread I read.

Quoted 6 lines
Quoted 2 lines

I did a significant amount of work to create the commits and series. I'm sorry if that's not clear, but it is in fact true.

Changes to the code or just reordering and merging commits? ?If the former, then I think Christoph's comment applies, if the latter, I think preserving authorship is still the right thing to do.

I changed both, switching to new kernel API's, clean ups, finding a minimum set of code for this support, and debugging that and fixing defects in the code. This wasn't a trivial amount of work to create the series and commits.

Daniel

--
Sent by an consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.

#27 lore raw
Quoted 9 lines · Dima Zavin

Really though? Let's look at one of them:

2 Arve Hjønnevåg <[email protected]>
6 Brian Swetland <[email protected]>
14 Dima Zavin <[email protected]>
2 Haley Teng <[email protected]>
1 Iliyan Malchev <[email protected]>
5 Mike Chan <[email protected]>

I'll add this list into the commit text ..

Daniel

Signature · 9 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.


--
To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
#28 lore raw
Quoted 4 lines · On Fri, 21 Jan 2011 12:49:55 -0800 Daniel Walker <[email protected]> wrote:
Quoted 2 lines · Dima Zavin

Really though? Let's look at one of them:

Quoted 8 lines
Quoted 6 lines

2 Arve Hj?nnev?g <[email protected]>
6 Brian Swetland <[email protected]>
14 Dima Zavin <[email protected]>
2 Haley Teng <[email protected]>
1 Iliyan Malchev <[email protected]>
5 Mike Chan <[email protected]>

I'll add this list into the commit text ..

Sounds like a good example of a patch where you should preserve the author field as well.

Signature · 1 line
Jesse Barnes, Intel Open Source Technology Center
#29 lore raw
Quoted 14 lines · Jesse Barnes
Quoted 11 lines · On Fri, 21 Jan 2011 12:49:55 -0800 Daniel Walker <[email protected]> wrote:
Quoted 9 lines · Dima Zavin

Really though? Let's look at one of them:

2 Arve Hj?nnev?g <[email protected]>
6 Brian Swetland <[email protected]>
14 Dima Zavin <[email protected]>
2 Haley Teng <[email protected]>
1 Iliyan Malchev <[email protected]>
5 Mike Chan <[email protected]>

Quoted 4 lines
Quoted 1 line

I'll add this list into the commit text ..

Sounds like a good example of a patch where you should preserve the author field as well.

preserve it as who ?

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#30 lore raw
Quoted 15 lines · Daniel Walker
Quoted 14 lines · Jesse Barnes
Quoted 11 lines · On Fri, 21 Jan 2011 12:49:55 -0800 Daniel Walker <[email protected]> wrote:
Quoted 9 lines · Dima Zavin

Really though? Let's look at one of them:

? ? ? 2 Arve Hj?nnev?g <[email protected]>
? ? ? 6 Brian Swetland <[email protected]>
? ? ?14 Dima Zavin <[email protected]>
? ? ? 2 Haley Teng <[email protected]>
? ? ? 1 Iliyan Malchev <[email protected]>
? ? ? 5 Mike Chan <[email protected]>

Quoted 6 lines
Quoted 4 lines
Quoted 1 line

I'll add this list into the commit text ..

Sounds like a good example of a patch where you should preserve the author field as well.

preserve it as who ?

My main point is that the authorship of this code is VERY easy to ascertain. It is not like a lot of other vendor code that gets thrown over the wall as a tarball. We really do our best to follow the right practices, give the right credits, create legible well separated commits, etc.

--Dima

#31 lore raw
Quoted 5 lines · Dima Zavin

My main point is that the authorship of this code is VERY easy to ascertain. It is not like a lot of other vendor code that gets thrown over the wall as a tarball. We really do our best to follow the right practices, give the right credits, create legible well separated commits, etc.

So your code was already submitted to Linus in a form that he'll accept, and Daniel is just completely wasting his time?

Signature · 2 lines
David Woodhouse                            Open Source Technology Centre
David.Woodhouse at intel.com                              Intel Corporation
#32 lore raw
In reply to Daniel Walker
Quoted 9 lines · Daniel Walker
Quoted 7 lines · Dima Zavin

Really though? Let's look at one of them:
2 Arve Hj?nnev?g <[email protected]>
6 Brian Swetland <[email protected]>
14 Dima Zavin <[email protected]>
2 Haley Teng <[email protected]>
1 Iliyan Malchev <[email protected]>
5 Mike Chan <[email protected]>

I'll add this list into the commit text ..

I think it'd be better if you pull them into a
git repository, then use either:
git format-patch
git send-email
or
git request-pull

That way no author history is lost.

cheers, Joe

#33 lore raw
Quoted 11 lines · Joe Perches
Quoted 9 lines · Daniel Walker
Quoted 7 lines · Dima Zavin

Really though? Let's look at one of them:
2 Arve Hj?nnev?g <[email protected]>
6 Brian Swetland <[email protected]>
14 Dima Zavin <[email protected]>
2 Haley Teng <[email protected]>
1 Iliyan Malchev <[email protected]>
5 Mike Chan <[email protected]>

I'll add this list into the commit text ..

Quoted 8 lines

I think it'd be better if you pull them into a
git repository, then use either:
git format-patch
git send-email
or
git request-pull

That way no author history is lost.

The history isn't upstreamable ..

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#34 lore raw

Hi Daniel,

Quoted 19 lines · Daniel Walker
Quoted 18 lines · Joe Perches
Quoted 9 lines · Daniel Walker
Quoted 7 lines · Dima Zavin

Really though? Let's look at one of them:
? ? ? 2 Arve Hj?nnev?g <[email protected]>
? ? ? 6 Brian Swetland <[email protected]>
? ? ?14 Dima Zavin <[email protected]>
? ? ? 2 Haley Teng <[email protected]>
? ? ? 1 Iliyan Malchev <[email protected]>
? ? ? 5 Mike Chan <[email protected]>

I'll add this list into the commit text ..

I think it'd be better if you pull them into a
git repository, then use either:
? ? ? git format-patch
? ? ? git send-email
or
? ? ? git request-pull

Quoted 3 lines
Quoted 1 line

That way no author history is lost.

The history isn't upstreamable ..

Why is that? I don't see any technical problem of upstreaming the original patches even if they don't compile (as long as they're not included in Makefiles or Kconfig files). There's no need to hide the real history even if it looks ugly...

Pekka

#35 lore raw
Quoted 4 lines · Pekka Enberg

Why is that? I don't see any technical problem of upstreaming the original patches even if they don't compile (as long as they're not included in Makefiles or Kconfig files). There's no need to hide the real history even if it looks ugly...

I've asked Daniel in private whether he'd mind posting the original set of patches which he based his work on to this thread.

I suspect that the situation is that there's many patches which he's taken from the repository and consolidated them down into a nice set of easy to review patches.

One of the problems of preserving the micro-detail of history right from the early inception of support for a platform is that quite often the early support is buggy or broken - it might not even compile. There may be 20 or so patches on top of that which eventually get it to a usable state.

Do we really want to put off people from reviewing patches because of the size of micro-development that happened prior to getting to a point where the result of that development is usable?

Tell me this: does a patch which cleanly adds support for board X get reviewed by more, the same, or less people than a set of twenty patches which goes about the same thing, adding code, removing previously added code, changing it again.

I personally _hate_ patch sets which do that, and I tend to ignore them (or maybe review the first twenty patches before taking a break... and then never going back to them) because I quickly get tired reading all that code - which means I'm not able to do an effective review. I suspect most people suffer from reviewer tiredness when faced with large patch sets changing the same code time and time again.

I personally believe that Daniel is doing the right thing here, except he needs to preserve a better record of authorship. I even think it's fine if he decides to drop people's sign-offs if he thinks the code has changed significantly from the original authors - provided he's willing to take responsibility for the submission of that code.

If you read what a sign-off means (the DCO) then it's clear that if the code has changed significantly, the original sign-offs do not apply anymore - the original sign-offs can't warrant that the modified code is covered by appropriate licenses or even that the person who modified their code has the rights to submit it.

Take a moment to think about that. If I took some of your code with your sign-off, changed it significantly by including someone elses work where there were no rights to submit that persons work into mainline, and I kept your sign-off on that, would you be happy when someone starts making accusations against you submitting their code?

The sign-offs make no representation of who was the author. In many cases where companies are involved, the first sign-off is the person who authorized the release of the code, not the person who wrote the code, so it's a complete mistake to attribute authorship by whoever was listed first in the Sign-off lines. Authorship may be jointly held by the first 4 people listed, and attributing authorship to only the first is just as bad as not attributing authorship at all.

Lastly, from the arguments being made over this, if they are supported, I think that people are saying that the actions listed in DCO (b) are no longer allowed, and so DCO (b) should be removed entirely as an acceptable practice. IOW, what's being promoted as "you must do" (iow, preserving all history) is completely contary to the allowances of DCO (b).

#36 lore raw

Russell,

I completely agree with you that the entire history of the evolution of the code is not interesting or useful to everyone on the list or in linux kernel tree. I'm not advocating posting the original patches (which as you rightfully point out are plentiful due to long development cycle). It would be a waste of time.

I also like how Daniel has split up the board file additions into nice small patches, and I already thanked him for doing this work.

All I ask is that if files are directly copied out of the tree with only slight modifications or if they are copied and stripped down for easier consumption, just say
Original Authors: <dude@co> if it's reasonable to gather who the primary contributors are. If that is hard due to lots of commits and squashes, even a Cc: to the people who wrote the code would have been enough. Had any of that been done, I would have not said a word.

I still do appreciate Daniel's efforts and the way he is splitting up the commits for public consumption, as they do logically make sense.

--Dima

Quoted 68 lines · Russell King - ARM Linux
Quoted 4 lines · Pekka Enberg

Why is that? I don't see any technical problem of upstreaming the original patches even if they don't compile (as long as they're not included in Makefiles or Kconfig files). There's no need to hide the real history even if it looks ugly...

I've asked Daniel in private whether he'd mind posting the original set of patches which he based his work on to this thread.

I suspect that the situation is that there's many patches which he's taken from the repository and consolidated them down into a nice set of easy to review patches.

One of the problems of preserving the micro-detail of history right from the early inception of support for a platform is that quite often the early support is buggy or broken - it might not even compile. ?There may be 20 or so patches on top of that which eventually get it to a usable state.

Do we really want to put off people from reviewing patches because of the size of micro-development that happened prior to getting to a point where the result of that development is usable?

Tell me this: does a patch which cleanly adds support for board X get reviewed by more, the same, or less people than a set of twenty patches which goes about the same thing, adding code, removing previously added code, changing it again.

I personally _hate_ patch sets which do that, and I tend to ignore them (or maybe review the first twenty patches before taking a break... and then never going back to them) because I quickly get tired reading all that code - which means I'm not able to do an effective review. ?I suspect most people suffer from reviewer tiredness when faced with large patch sets changing the same code time and time again.

I personally believe that Daniel is doing the right thing here, except he needs to preserve a better record of authorship. ?I even think it's fine if he decides to drop people's sign-offs if he thinks the code has changed significantly from the original authors - provided he's willing to take responsibility for the submission of that code.

If you read what a sign-off means (the DCO) then it's clear that if the code has changed significantly, the original sign-offs do not apply anymore - the original sign-offs can't warrant that the modified code is covered by appropriate licenses or even that the person who modified their code has the rights to submit it.

Take a moment to think about that. ?If I took some of your code with your sign-off, changed it significantly by including someone elses work where there were no rights to submit that persons work into mainline, and I kept your sign-off on that, would you be happy when someone starts making accusations against you submitting their code?

The sign-offs make no representation of who was the author. ?In many cases where companies are involved, the first sign-off is the person who authorized the release of the code, not the person who wrote the code, so it's a complete mistake to attribute authorship by whoever was listed first in the Sign-off lines. ?Authorship may be jointly held by the first 4 people listed, and attributing authorship to only the first is just as bad as not attributing authorship at all.

Lastly, from the arguments being made over this, if they are supported, I think that people are saying that the actions listed in DCO (b) are no longer allowed, and so DCO (b) should be removed entirely as an acceptable practice. ?IOW, what's being promoted as "you must do" (iow, preserving all history) is completely contary to the allowances of DCO (b).

#37 lore raw
Quoted 7 lines · Dima Zavin

All I ask is that if files are directly copied out of the tree with only slight modifications or if they are copied and stripped down for easier consumption, just say
Original Authors: <dude@co> if it's reasonable to gather who the primary contributors are. If that is hard due to lots of commits and squashes, even a Cc: to the people who wrote the code would have been enough. Had any of that been done, I would have not said a word.

Well, having read what Thomas said in his mail:

Thomas said:
| Patch 3/7 is extracted from another large dump (37431502c4) in the | android tree which has:
[diffstat summary cut]

| And if you look at the above 37431502c4 commit then you'll notice that
| the author is Dima Zavin <[email protected]>, while in fact the whole
| commit is a conglomerate of commits from some other place with 16
| different authors, but there is no way to identify who wrote what.

I decided to investigate:

http://android.git.kernel.org/?p=kernel/msm.git;a=commit;h=37431502c4

| author	Dima Zavin <[email protected]>
| committer	Arve Hj?nnev?g <[email protected]>
|
| [ARM] msm: mahimahi: Update the memory map.
| 
| - move framebuffer to SMI and mdp pmem to bank 2 of EBI
| - remove the gpu pmem regions since we now use the MMU
| - move the adsp region to bank 2, and make it bigger (41MB vs 32MB)
| - move ram console to SMI
| 
| Change-Id: I88b4033e98374fc038609fbbb1c7e5cbed4f87c4
| Signed-off-by: Dima Zavin <[email protected]>
| 
| [ARM] msm: mahimahi: Expand memory available to kernel to 219MB
| 
| Change-Id: I59e69ce4209d16ce9804d3fa81814c9d0bda9a03
| Signed-off-by: Dima Zavin <[email protected]>
| 
| [ARM] msm: mahimahi: Read bluetooth address from ATAG and export in sysfs.
| 
| Signed-off-by: Nick Pelly <[email protected]>

... etc ...

Those change IDs are meaningless, they provide no way for external people to trace the history of the original commits and work out who did what in the resulting diff.

Maybe you could illustrate how to take that particular commit, which Daniel apparantly based his 3/7 patch on, and identify who Daniel should and should not give credit to using *just* the text in that commit and no other information.

If you can't do that without reference to some other information, then I don't think you have a leg to stand on when complaining to Daniel about not giving credit, as you've made it impossible for that to happen.

While it is not fair _not_ to give credit to people who worked on a particular piece of code, it is also not fair _to_ give credit to people who didn't work on that same code. It erodes the value of crediting the real authors.

I'd say that Daniel is doing a bloody good job, everything considered.

#38 lore raw
Quoted 6 lines · Russell King - ARM Linux

http://android.git.kernel.org/?p=kernel/msm.git;a=commit;h=37431502c4

Maybe you could illustrate how to take that particular commit, which Daniel apparantly based his 3/7 patch on, and identify who Daniel should and should not give credit to using *just* the text in that commit and no other information.

I'd add a:

"Based a on shitty codedump from a secrit Google repository, credited to
Dima Zavin <[email protected]>."

at the end of the commit line and Cc Dima to see if there's any interested from his side to sort this out. But maybe that's just my attitude, and a less colourful language would also do it.

#39 lore raw
In reply to Russell King - ARM Linux
Quoted 10 lines · Russell King - ARM Linux

One of the problems of preserving the micro-detail of history right from the early inception of support for a platform is that quite often the early support is buggy or broken - it might not even compile. There may be 20 or so patches on top of that which eventually get it to a usable state.

Do we really want to put off people from reviewing patches because of the size of micro-development that happened prior to getting to a point where the result of that development is usable?

...

Quoted 7 lines

I personally believe that Daniel is doing the right thing here, except he needs to preserve a better record of authorship. I even think it's fine if he decides to drop people's sign-offs if he thinks the code has changed significantly from the original authors - provided he's willing to take responsibility for the submission of that code.

Quoted 5 lines

If you read what a sign-off means (the DCO) then it's clear that if the code has changed significantly, the original sign-offs do not apply anymore - the original sign-offs can't warrant that the modified code is covered by appropriate licenses or even that the person who modified their code has the rights to submit it.

I completely agree that it's not realistic that the entire development history of this code be preserved as it goes upstream. Nobody needs to see the 20-30 fiddly changes over a couple months of people from three companies tinkering with subtleties of the SCPLL sequencing for QSD8x50, when the end result is (hopefully) 200-300 lines of working code.

I also will state that I have absolutely no problem with people picking patches that we've made available, tidying things up, and pushing them into mainline, particularly bits that have languished for a while. At the same time, we're working to improving our process for future work -- for example the Tegra2 development efforts, I believe, have been a step forward as far as getting stuff upstream from the start of a project.

All we ask is that some reasonable acknowledgement of original authorship is maintained for non-trivial work. A 5-10 line patch that deals with mechanical issues of board files or cleans stuff up is no big deal. 100s of lines that represent some real work is something else.

I'm in the same boat as Daniel much of the time, since we often do spend some time toward the end of a development cycle collapsing a bunch of patches from multiple developers at Google or closely-working OEM partners down into a smaller set that hopefully makes a little bit more sense.

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

Author: Awesome Upstreamer <[email protected]> or Main Author <[email protected]>
Committer: Awesome Upstreamer <[email protected]>
Subject: arm: msm8k: acpu clock management

... summary of the patch ...

Original-Author: Joe Firmware Guy <[email protected]>
Original-Author: Kernel Droid <[email protected]>
Signed-off-by: ...

Though I'm not sure "Original-Author" is the best phrasing here... Or perhaps just having the patch description end with "This patch is based on original code by Joe Firmware Guy, Kernel Droid, etc is the way to go. I do think that for work where there is one clear original author, it's nice to leave them as the Author, but at the end of the day, provided the code's heading in the right direction and the contributors are acknowledged, that's a detail.

If there's some consensus on the way to do this, we can make sure to use the same method when we're collapsing history on our own patchsets (obviously the current model we're using can be messy and confusing) to simplify things going forward.

Brian

#40 lore raw
Quoted 5 lines · Brian Swetland

All we ask is that some reasonable acknowledgement of original authorship is maintained for non-trivial work. A 5-10 line patch that deals with mechanical issues of board files or cleans stuff up is no big deal. 100s of lines that represent some real work is something else.

So... What about http://article.gmane.org/gmane.linux.ports.arm.msm/167 ? Is that good enough for you? If no, then could you please propose an alternative? If that is indeed good enough, then could we please move on?

Quoted 13 lines

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

Author: Awesome Upstreamer <[email protected]> or Main Author <[email protected]>
Committer: Awesome Upstreamer <[email protected]>
Subject: arm: msm8k: acpu clock management

... summary of the patch ...

Original-Author: Joe Firmware Guy <[email protected]>
Original-Author: Kernel Droid <[email protected]>
Signed-off-by: ...

Quoted 7 lines

Though I'm not sure "Original-Author" is the best phrasing here... Or perhaps just having the patch description end with "This patch is based on original code by Joe Firmware Guy, Kernel Droid, etc is the way to go. I do think that for work where there is one clear original author, it's nice to leave them as the Author, but at the end of the day, provided the code's heading in the right direction and the contributors are acknowledged, that's a detail.

I think a free form list of contributors in the commit log should be fine, possibly adding them in CC to the patch submission as well.

There is a _huge_ value in the action of making code palatable for mainline inclusion and actually pushing that code into mainline. If you do it yourself next time instead of letting your code rot then no one might be tempted to stump on your authorship.

Nicolas

#41 lore raw
Quoted 11 lines · Nicolas Pitre
Quoted 5 lines · Brian Swetland

All we ask is that some reasonable acknowledgement of original authorship is maintained for non-trivial work. ?A 5-10 line patch that deals with mechanical issues of board files or cleans stuff up is no big deal. ?100s of lines that represent some real work is something else.

So... What about http://article.gmane.org/gmane.linux.ports.arm.msm/167 ? Is that good enough for you? ?If no, then could you please propose an alternative? ?If that is indeed good enough, then could we please move on?

Something like:

Based on code written by:
<list of names>

is absolutely fine by me. Including patch counts, etc, is not essential.

Quoted 21 lines
Quoted 13 lines

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

Author: Awesome Upstreamer <[email protected]> ?or ?Main Author <[email protected]>
Committer: Awesome Upstreamer <[email protected]>
Subject: arm: msm8k: acpu clock management

... summary of the patch ...

Original-Author: Joe Firmware Guy <[email protected]>
Original-Author: Kernel Droid <[email protected]>
Signed-off-by: ...

Quoted 7 lines

Though I'm not sure "Original-Author" is the best phrasing here... ?Or perhaps just having the patch description end with "This patch is based on original code by Joe Firmware Guy, Kernel Droid, etc is the way to go. ?I do think that for work where there is one clear original author, it's nice to leave them as the Author, but at the end of the day, provided the code's heading in the right direction and the contributors are acknowledged, that's a detail.

Quoted 2 lines

I think a free form list of contributors in the commit log should be fine, possibly adding them in CC to the patch submission as well.

That seems reasonable to me.

Quoted 4 lines

There is a _huge_ value in the action of making code palatable for mainline inclusion and actually pushing that code into mainline. If you do it yourself next time instead of letting your code rot then no one might be tempted to stump on your authorship.

Certainly. As long as we're acknowledging both the contributions of those who wrote the code and those who are doing the heavy lifting to get it upstream, we're happy. We are, of course, working on doing things better in the future -- the tegra2 efforts are a direct result of our desire to get things right on a newer project.

Brian

#42 lore raw
In reply to Brian Swetland
Quoted 2 lines · Brian Swetland

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

If you do a grep "Based on" in git-log output you'll see that this is a pretty common and thus defacto standard for attributing substantial modified patches.

#43 lore raw
In reply to Brian Swetland
Quoted 2 lines · Brian Swetland

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

I asked for the answer to a _specific_ example. If you can't answer that example, then you *can't* expect Daniel to either, and it is utterly unreasonable to demand it of him.

#44 lore raw
Quoted 7 lines · On Sat, 22 Jan 2011 21:04:05 +0000 Russell King - ARM Linux…
Quoted 2 lines · Brian Swetland

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

I asked for the answer to a _specific_ example. If you can't answer that example, then you *can't* expect Daniel to either, and it is utterly unreasonable to demand it of him.

I've always just put it in the text. I'm not fond of it being in URLs because some day they break and move, at least if the list of names is in the git log it's ensuring the contributor data isn't going to get completely lost.

Yeah

Based on blah by
name
name
name
name
name

isn't the most thrilling git commit message but it works and sometimes you can even generate the list with grep

#45 lore raw
In reply to Brian Swetland
Quoted 8 lines · Brian Swetland

What would be useful would be a reasonable convention for acknowledging multiple authors, perhaps something along the lines of:

Author: Awesome Upstreamer <[email protected]> or Main Author <[email protected]>
Committer: Awesome Upstreamer <[email protected]>
Subject: arm: msm8k: acpu clock management

Quoted 5 lines

... summary of the patch ...

Original-Author: Joe Firmware Guy <[email protected]>
Original-Author: Kernel Droid <[email protected]>
Signed-off-by: ...

Nah, sod that. If the original authors couldn't be bothered to do their work properly in the first place so that it was upstreamable, then as far as I'm concerned they don't deserve the credit.

We should do the bare minimum that's required by copyright law, which is making sure that the code is permitted in the kernel under the GPL.

Since the GPL doesn't have, and doesn't *allow*, a clause like the BSD advertising clause, we have no requirement to credit the original authors.

If they wanted credit, they should have done the job right in the first place. Or at least finished the job for themselves rather than forcing someone else to clean up their mess.

Signature · 2 lines
David Woodhouse                            Open Source Technology Centre
David.Woodhouse at intel.com                              Intel Corporation
#46 lore raw
In reply to Russell King - ARM Linux
Quoted 13 lines · Russell King - ARM Linux

I've asked Daniel in private whether he'd mind posting the original set of patches which he based his work on to this thread.

I suspect that the situation is that there's many patches which he's taken from the repository and consolidated them down into a nice set of easy to review patches.

One of the problems of preserving the micro-detail of history right from the early inception of support for a platform is that quite often the early support is buggy or broken - it might not even compile. There may be 20 or so patches on top of that which eventually get it to a usable state.

Quoted 3 lines

Do we really want to put off people from reviewing patches because of the size of micro-development that happened prior to getting to a point where the result of that development is usable?

No, not at all. And I'm really annoyed at all the pointless flaming here as people obviously never had to massage a completely messy repository into something submittable. That usually doesn't just include making useful commits, but also updates to current APIs, bug fixing, removing crap that should never make it's way upstream (and Android had quite a lot of the latter last time I looked).

The only think that Daniel did wrong was to not attribute the original authors in the commit message, and not explaining his own contribution.

#47 lore raw
In reply to Daniel Walker
Quoted 8 lines · Dima Zavin
Quoted 8 lines

Really though? Let's look at one of them:

? ? ? 2 Arve Hj?nnev?g <[email protected]>
? ? ? 6 Brian Swetland <[email protected]>
? ? ?14 Dima Zavin <[email protected]>
? ? ? 2 Haley Teng <[email protected]>
? ? ? 1 Iliyan Malchev <[email protected]>
? ? ? 5 Mike Chan <[email protected]>

Quoted 1 line · Daniel Walker

I'll add this list into the commit text ..

So why is everyone bitching at Daniel when he's doing something the Android folks should have done themselves a long time ago?

Pekka

#48 lore raw
Quoted 2 lines · Pekka Enberg

Daniel doing something the
Android folks should have done themselves a long time ago?

I think it's more polite myself.

I agree that ideally the androiding googlers (googly androids?) should submit it.

Dima? Are you doing anything useful right now?

cheers, Joe

#49 lore raw
In reply to Pekka Enberg
Quoted 6 lines · Pekka Enberg
Quoted 1 line · Daniel Walker

I'll add this list into the commit text ..

So why is everyone bitching at Daniel when he's doing something the Android folks should have done themselves a long time ago?

Two wrongs don't make a right. And it's not like not submitting changes is wrong, although granted it's not ideal. (I'd say removing attribution from a git commit is even worse. If you're doing the equivalent of a cherry pick, you should preserve the Author field. Even if you're doing some cleanup work, as the maintainer I generally preserve the Author line, and will simply add the fact that I did some cleanup to the commit body. The question is who did more work; the person who originally submitted the code, or the person who did the cleanup.)

- Ted

#50 lore raw
Quoted 5 lines · Ted Ts'o
Quoted 4 lines · Pekka Enberg
Quoted 1 line · Daniel Walker

I'll add this list into the commit text ..

Quoted 7 lines
Quoted 2 lines

So why is everyone bitching at Daniel when he's doing something the Android folks should have done themselves a long time ago?

Two wrongs don't make a right. And it's not like not submitting changes is wrong, although granted it's not ideal. (I'd say removing attribution from a git commit is even worse. If you're doing the equivalent of a cherry pick, you should preserve the Author field.

right, but it wasn't a cherrypick which was explain in the thread. So there's no wrongs here ..

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#51 lore raw
Quoted 3 lines · Daniel Walker

right, but it wasn't a cherrypick which was explain in the thread. So there's no wrongs here ..

I'm sorry Daniel, but you are absolutely wrong!

Did you come up with the logic of this code, or did you take someone else's code and just massage it until it worked?

If you took someone else's code, where are their Signed-off-by's?

Just look at what I did recently with Lai's rt-mutex clean up patch. I ported it to the PREEMPT_RT (-rt) patch set. That port took me a week to do. I had to add a bunch of code to make it work. When it was finished, did I claim author of it? No! I left Lai as the author and simply added:

[ Ported to the -rt patch set by Steven Rostedt ]

Take a look at the changes.

Here's the patch I started with:

https://patchwork.kernel.org/patch/477841/

Here's what I ended with (all my changes)

https://patchwork.kernel.org/patch/470171/

Do a diff of the two. There was a lot of work going into that. But I did not come up with change to the algorithm that Lai did, so I kept him as author. I just added my insert in the change log and added my own SoB (including his).

If I repaint a Picasso, can I call it a Rostedt?

-- Steve

#52 lore raw
Quoted 6 lines · Steven Rostedt
Quoted 3 lines · Daniel Walker

right, but it wasn't a cherrypick which was explain in the thread. So there's no wrongs here ..

I'm sorry Daniel, but you are absolutely wrong!

This thread is getting way out of hand .. I think you really don't understand what has happened here.. That's fine tho, if you don't like what I've done then NAK, I'm not going to argue with any you.

Daniel

Signature · 3 lines
Sent by an consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum.
#53 lore raw
Quoted 11 lines · Daniel Walker
Quoted 6 lines · Steven Rostedt
Quoted 3 lines · Daniel Walker

right, but it wasn't a cherrypick which was explain in the thread. So there's no wrongs here ..

I'm sorry Daniel, but you are absolutely wrong!

This thread is getting way out of hand .. I think you really don't understand what has happened here.. That's fine tho, if you don't like what I've done then NAK, I'm not going to argue with any you.

Sorry for coming off a bit strong, but I've known you for a while, and that is usually the best way to get you to understand.

I don't want to argue, but instead teach you that there is a process of getting code into the kernel, and a etiquette (not to mention legal) way of doing things.

If you take code from someone else, look at it, and make it work, or do whatever changes to it. You must keep some form of authorship with the original author. If you rewrote it completely so that it doesn't look anything like what the original code was, then sure, its yours. But then the copyright would belong to you.

But you stated that the copyright was not yours but googles. You are not employed by google are you? The major problem I have with these patches is that you got code from somewhere else but had no Signed-off-bys from anyone. This is where legal comes in.

How do you know this code was attained legally? Can you take sole responsibility that the code was not stolen from non GPL code? The only tag line in a change log that matters is that Signed-off-by. Its the one with (sorta) legal powers. This is saying that you verify that this code was given to you through legal means. Either that you wrote the code yourself and are not under any contract to keep it from becoming GPL, or you took it from someone that gave you their own Signed-off-by that you can trust.

The biggest problem with your patch set is that it is missing the necessary Signed-off-bys. Also, the only Signed-off-by that you can write is your own. Someone can give you their Signed-off-by and you can add it. There's been patches that I would not accept until the author gave me (usually publicly) their Signed-off-by.

If you had those, I would not have written the email that I wrote.

-- Steve

#54 lore raw
In reply to Daniel Walker
Quoted 3 lines · Daniel Walker

right, but it wasn't a cherrypick which was explain in the thread. So there's no wrongs here ..

I said the *equivalent* of a cherry-pick. And in general, if I'm taking things from another git tree, I'll try to preserve the commit structure as much as possible, preserve the Author: information, as well as reference the original git tree and commit id's, and of course, keep the signed-off-by's. That's true even if I need to do fairly significant work to port it to the current tree.

In some cases, of course, that might not be possible. But in general, it's much better to err on the side of including authorship than not. Note the big uproar that happened when the code from BSD wireless drivers were imported in without due care for attribution. In the case of pulling commits from another Linux kernel source tree, there isn't even the excuse of needing to port from a completely different OS's infrastructure.

If there is a desire to keep the git tree bisectable, and the order in which things were checked in don't allow for tree bisectability, sure, that might be a reason to collapse commits together; but even then, I'd probably choose one of the Author's of the two original commits as the Author field, instead of substituting my name in.

Best regards,

- Ted

#55 lore raw
In reply to Ted Ts'o

Hi Ted,

Quoted 1 line · Daniel Walker
Quoted 1 line
Quoted 1 line

I'll add this list into the commit text ..

Quoted 2 lines · Pekka Enberg
Quoted 2 lines

So why is everyone bitching at Daniel when he's doing something the Android folks should have done themselves a long time ago?

Quoted 9 lines · Ted Ts'o

Two wrongs don't make a right. And it's not like not submitting changes is wrong, although granted it's not ideal. (I'd say removing attribution from a git commit is even worse. If you're doing the equivalent of a cherry pick, you should preserve the Author field. Even if you're doing some cleanup work, as the maintainer I generally preserve the Author line, and will simply add the fact that I did some cleanup to the commit body. The question is who did more work; the person who originally submitted the code, or the person who did the cleanup.)

Sure, it would have been nicer for everyone involved if Daniel would have kept the original patches and added new patches to clean it up on top of that to preserve the history. However, I don't understand the harsh comments when this looks like a honest mistake! And I especially don't understand the almost hostile attitude of the Android developers who have been sitting on these patches for over a year now AFAICT.

Pekka

#56 lore raw
Quoted 20 lines · Pekka Enberg

Hi Ted,

Quoted 1 line · Daniel Walker
Quoted 1 line
Quoted 1 line

I'll add this list into the commit text ..

Quoted 2 lines · Pekka Enberg
Quoted 2 lines

So why is everyone bitching at Daniel when he's doing something the Android folks should have done themselves a long time ago?

Quoted 9 lines · Ted Ts'o

Two wrongs don't make a right. ?And it's not like not submitting changes is wrong, although granted it's not ideal. ?(I'd say removing attribution from a git commit is even worse. ?If you're doing the equivalent of a cherry pick, you should preserve the Author field. Even if you're doing some cleanup work, as the maintainer I generally preserve the Author line, and will simply add the fact that I did some cleanup to the commit body. ?The question is who did more work; the person who originally submitted the code, or the person who did the cleanup.)

Quoted 5 lines

Sure, it would have been nicer for everyone involved if Daniel would have kept the original patches and added new patches to clean it up on top of that to preserve the history. However, I don't understand the harsh comments when this looks like a honest mistake! And I especially don't understand the almost hostile attitude of the Android developers

There's absolutely no hostility. I stated from the very beginning that I appreciate the voluntary effort by a 3rd party to upstream the board files. I only asked that proper authorship be attributed, which is standard linux kernel patch submission procedure when the committer did not originate the code.

Quoted 1 line

who have been sitting on these patches for over a year now AFAICT.

Even if that were true, that does not somehow revoke the original author/contributor list.

--Dima

#57 lore raw
Quoted 38 lines · Dima Zavin
Quoted 20 lines · Pekka Enberg

Hi Ted,

Quoted 1 line · Daniel Walker
Quoted 1 line
Quoted 1 line

I'll add this list into the commit text ..

Quoted 2 lines · Pekka Enberg
Quoted 2 lines

So why is everyone bitching at Daniel when he's doing something the Android folks should have done themselves a long time ago?

Quoted 9 lines · Ted Ts'o

Two wrongs don't make a right. ?And it's not like not submitting changes is wrong, although granted it's not ideal. ?(I'd say removing attribution from a git commit is even worse. ?If you're doing the equivalent of a cherry pick, you should preserve the Author field. Even if you're doing some cleanup work, as the maintainer I generally preserve the Author line, and will simply add the fact that I did some cleanup to the commit body. ?The question is who did more work; the person who originally submitted the code, or the person who did the cleanup.)

Quoted 5 lines

Sure, it would have been nicer for everyone involved if Daniel would have kept the original patches and added new patches to clean it up on top of that to preserve the history. However, I don't understand the harsh comments when this looks like a honest mistake! And I especially don't understand the almost hostile attitude of the Android developers

There's absolutely no hostility. I stated from the very beginning that I appreciate the voluntary effort by a 3rd party to upstream the board files. I only asked that proper authorship be attributed, which is standard linux kernel patch submission procedure when the committer did not originate the code.

Quoted 1 line

who have been sitting on these patches for over a year now AFAICT.

Even if that were true, that does not somehow revoke the original author/contributor list.

Quoted 7 lines

--Dima
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo at vger.kernel.org
More majordomo info at ?http://vger.kernel.org/majordomo-info.html Please read the FAQ at ?http://www.tux.org/lkml/

Can you show how to import history ? Until then, a line like From:
x at y.x I think will be fine.
And maybe an link to https://review.source.android.com/'some review'

#58 lore raw
Quoted 3 lines · Anca Emanuel

Can you show how to import history ? Until then, a line like From:
x at y.x I think will be fine.
And maybe an link to https://review.source.android.com/'some review'

The best solution is to keep the original patches as-is and rebase Daniel's cleanups on top of those.

#59 lore raw
In reply to Dima Zavin

Hi Dima!

Quoted 5 lines · Dima Zavin

There's absolutely no hostility. I stated from the very beginning that I appreciate the voluntary effort by a 3rd party to upstream the board files. I only asked that proper authorship be attributed, which is standard linux kernel patch submission procedure when the committer did not originate the code.

OK, that's great! It's poorly reflected in this discussion thread, though.

Quoted 4 lines
Quoted 1 line

who have been sitting on these patches for over a year now AFAICT.

Even if that were true, that does not somehow revoke the original author/contributor list.

No, it does not. But it does make me much more sympathetic towards Daniel's efforts even though authorship info is misappropriated. It's not as if he changed copyrights or anything malicious like that so I do think people are making this into a bigger thing than it really is.

Anyway, I hope Daniel has the time to rebase his patches on top of your original ones so history is preserved and we can get this stuff merged.

Pekka

#60 lore raw
Quoted 16 lines · Pekka Enberg

Hi Dima!

Quoted 5 lines · Dima Zavin

There's absolutely no hostility. I stated from the very beginning that I appreciate the voluntary effort by a 3rd party to upstream the board files. I only asked that proper authorship be attributed, which is standard linux kernel patch submission procedure when the committer did not originate the code.

OK, that's great! It's poorly reflected in this discussion thread, though.

Quoted 4 lines
Quoted 1 line

who have been sitting on these patches for over a year now AFAICT.

Even if that were true, that does not somehow revoke the original author/contributor list.

Quoted 8 lines

No, it does not. But it does make me much more sympathetic towards Daniel's efforts even though authorship info is misappropriated. It's not as if he changed copyrights or anything malicious like that so I do think people are making this into a bigger thing than it really is.

Anyway, I hope Daniel has the time to rebase his patches on top of your original ones so history is preserved and we can get this stuff merged.

Crap. There is no history which has remotely to do anything with Daniel patches, which are btw. very sensible and well done.

Patch 1/7 is extracted from one large dump (f5ee31ab10c1) in the android tree, which has:

	9 files changed, 1445 insertions(+), 45 deletions(-)

versus Daniels patch:

       1 files changed, 42 insertions(+), 0 deletions(-)

Patch 2/7 is properly assigned to the original author.

Patch 3/7 is extracted from another large dump (37431502c4) in the android tree which has:

      11 files changed, 5336 insertions(+), 6 deletions(-)

versus Daniels patch:

       4 files changed, 484 insertions(+), 1 deletions(-)

And if you look at the above 37431502c4 commit then you'll notice that the author is Dima Zavin <[email protected]>, while in fact the whole commit is a conglomerate of commits from some other place with 16 different authors, but there is no way to identify who wrote what.

How the f*ck should Daniel attribute the authorship from that shit pile? And the person who "authored" that mega commit is now complaining.

I stoppped looking at this point as the whole "so well done" android tree is a huge stinking pile of sh*t! Not only code wise, also the history is completely useless due to these mega commits which have no reference at all.

The only thing what Daniel missed is to add in the change log of his patches:

Extracted from: git-url branch commit ID
or:
Based on: git-url branch commit ID

That's oversight and not a malicious crime and easy to repair.

The people who make a lot of noise about this including you did not even bother to look at the patches and the originating mess, which is in no way suitable to go near mainline in any form.

I really appreciate the well structured effort which Daniel is putting into this. An effort which should have been done in the first place by those who cry murder now.

Thanks,

tglx

Acked-by Kalle Valo
#61 lore raw
Quoted 2 lines · Thomas Gleixner

I really appreciate the well structured effort which Daniel is putting into this.

Me too.

I've an issue similar to the problem mentioned in this thread:
I own a board which came,by default with a 2.6.27 kernel.
A developer of the company that produced and sell the board ported the board to the 2.6.30 kernel during his spare time(if I remember well) The patch is publicly available in their svn tree in the form of a standard unified diff patch(not a git patch)

Is that the proper format for the commit message:
mx31: add support for the bugbase 1.3 from buglabs

This work was based on bug-linux-2.6.30.patch that can be found
in buglabs's svn here:
svn://bugcamp.net/bug/branches/izzy/experimental

The work I did was porting forward the board initialization code and the serial port support from 2.6.30 to linux-next.
I debugged(with md in uboot to get the printk buffer) the fact that the serial didn't work,and removed unneeded code to make it work.

I've not submitted yet the work because of this thread, thanks to Russell King's response I think I'll submit it.

Here's another commit I made and that went into mainline:
commit 9df86e2e702c6d5547aced7f241addd2d698bb11

Author: Denis 'GNUtoo' Carikli <[email protected]>
Date:   Fri Aug 27 23:48:19 2010 +0200

wl1251: Fix queue stopping/waking for TX path

This patch was adapted from 06f7bc7db79fabe6b2ec16eff0f59e4acc21eb72 (from linus's linux-2.6 tree of kernel.org)

here's the original message:
The queue stopping/waking functionality was broken in a way that
could
cause huge latencies in TX transfers and even cause the TX to stall
in the
right circumstances. Correct these problems.

In this commit I was told not to put the original sign-off, authors etc...
This is because it would have been confusing and misleading:
It would have appeared like if the commit got Ack,Sign-off etc... by the people involved in the original commit.

Denis.

#62 lore raw

Denis,

Your approach would have been fine as well. Some mechanism to point out where the original lives like pasting a link saying 'Original code can be found in <url>" or "Based on the code as found in <url>" as you did would have also been enough as well.

--Dima

Quoted 62 lines · Denis 'GNUtoo' Carikli
Quoted 2 lines · Thomas Gleixner

I really appreciate the well structured effort which Daniel is putting into this.

Me too.

I've an issue similar to the problem mentioned in this thread:
I own a board which came,by default with a 2.6.27 kernel.
A developer of the company that produced and sell the board ported the board to the 2.6.30 kernel during his spare time(if I remember well) The patch is publicly available in their svn tree in the form of a standard unified diff patch(not a git patch)

Is that the proper format for the commit message:
? ?mx31: add support for the bugbase 1.3 from buglabs

? ?This work was based on bug-linux-2.6.30.patch that can be found ? ? ?in buglabs's svn here:
? ? ?svn://bugcamp.net/bug/branches/izzy/experimental

? ?Signed-off-by: Denis 'GNUtoo' Carikli <[email protected]>

The work I did was porting forward the board initialization code and the serial port support from 2.6.30 to linux-next.
I debugged(with md in uboot to get the printk buffer) the fact that the serial didn't work,and removed unneeded code to make it work.

I've not submitted yet the work because of this thread, thanks to Russell King's response I think I'll submit it.

Here's another commit I made and that went into mainline:
commit 9df86e2e702c6d5547aced7f241addd2d698bb11
Author: Denis 'GNUtoo' Carikli <[email protected]>
Date: ? Fri Aug 27 23:48:19 2010 +0200

wl1251: Fix queue stopping/waking for TX path

This patch was adapted from 06f7bc7db79fabe6b2ec16eff0f59e4acc21eb72 (from linus's linux-2.6 tree of kernel.org)

here's the original message:
? ?The queue stopping/waking functionality was broken in a way that could
? ?cause huge latencies in TX transfers and even cause the TX to stall in the
? ?right circumstances. Correct these problems.

In this commit I was told not to put the original sign-off, authors etc...
This is because it would have been confusing and misleading:
It would have appeared like if the commit got Ack,Sign-off etc... by the people involved in the original commit.

Denis.

#63 lore raw
In reply to Pekka Enberg
Quoted 3 lines · Pekka Enberg

Sure, it would have been nicer for everyone involved if Daniel would have kept the original patches and added new patches to clean it up on top of that to preserve the history.

No, it would be a complete fucking mess that way. We tell people to submit standalone and well formed patches all the time. Why would it make any difference just because they were also commited to a shitty git tree somewhere else?

#64 lore raw

Hi Christoph!

Quoted 3 lines · Pekka Enberg
Quoted 3 lines

Sure, it would have been nicer for everyone involved if Daniel would have kept the original patches and added new patches to clean it up on top of that to preserve the history.

Quoted 4 lines · Christoph Hellwig

No, it would be a complete fucking mess that way. ?We tell people to submit standalone and well formed patches all the time. ?Why would it make any difference just because they were also commited to a shitty git tree somewhere else?

We also tell people to submit crap into tree all the time - it's called staging! We also merge full history from time to time like in the case of btrfs.

Usually even "shitty git trees" have value in the history for people who're interested why the code is the way it is. But as people who actually looked at the patches, it doesn't apply here.

Pekka

#65 lore raw
Quoted 2 lines · Pekka Enberg

We also tell people to submit crap into tree all the time - it's called staging!

Which is totally unrelated to this flameware. Also if crap goes into staging it doesn't go with years of useless version history.

Quoted 2 lines

We also merge full history from time to time like in the case of btrfs.

We do it something, but only for projects that actually follow the Linux commit guidelines.

Quoted 3 lines

Usually even "shitty git trees" have value in the history for people who're interested why the code is the way it is. But as people who actually looked at the patches, it doesn't apply here.

Thomas posted how the android tree commits looks. How about getting a clue before posting more useless noise in this thread?

#66 lore raw
Quoted 6 lines · Christoph Hellwig
Quoted 3 lines

Usually even "shitty git trees" have value in the history for people who're interested why the code is the way it is. But as people who actually looked at the patches, it doesn't apply here.

Thomas posted how the android tree commits looks. ?How about getting a clue before posting more useless noise in this thread?

Oh, don't you even try to "pull a Christoph" on me! I did see Thomas' and Russell's comments about the quality of the tree which is why I said "it doesn't apply here" (that the history is useless).

#67 lore raw
In reply to Daniel Walker
Quoted 10 lines · Daniel Walker

This series adds basic Nexus One support which includes a booting kernel, and functional MMC .

Most people won't be able to use this yet unfortunately because you need a serial cable to get any output. However, it's a start.

msm: mahimahi: add mahimahi board file
msm: mahimahi: add in mmc support code
msm: mahimahi: add gpio pin muxing code
msm: mahimahi: initialize mmc at start up

Even you call the machine Nexus One... can you be a tiny bit more consistent with it?

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#68 lore raw
Quoted 7 lines · Pavel Machek
Quoted 5 lines · Daniel Walker

This series adds basic Nexus One support which includes a booting kernel, and functional MMC .

Most people won't be able to use this yet unfortunately because you need a serial cable to get any output. However, it's a start.

Quoted 7 lines
Quoted 4 lines

msm: mahimahi: add mahimahi board file
msm: mahimahi: add in mmc support code
msm: mahimahi: add gpio pin muxing code
msm: mahimahi: initialize mmc at start up

Even you call the machine Nexus One... can you be a tiny bit more consistent with it?

I tried to call it Nexus One in this release note cause no one knows what a "mahimahi" is .. I would like to call it Nexus One all over, but I can't because Google uses the name mahimahi..

Daniel

Signature · 2 lines
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.