Skip to contentSkip to conversation

My patch queue for memorystick subsystem

PATCH In review Maxim Levitsky 3 participants 84 messages Oct 22, 2010 – Oct 26, 2010

Subsystems (2)
lore
Share & tools
lore

Maxim Levitsky

author maintainer
#0 lore raw

cover My patch queue for memorystick subsystem

Hi,

As requested, this is split up series of the work I did for the memorystick subsystem.

All patches compile tested.
All patches except jmicron patches also run tested on my r592
The end result of jmicron patches is exactly the same as my old patch that did work very well. I will test the patches tommorow though to ensure that all of them work for bisectability.

Please review & merge.

Best regards,
Maxim Levitsky

author maintainer
#1 lore raw

PATCH 1/29 memstick: core: header cleanups

* Replace the __attribute__((packed)) with __packed
* Add struct mspro_cmdex_argument, argument for MS_TPC_EX_SET_CMD
* Increase size of inline buffer in memstick_request to 32 because thats the size of registers and someone might need to read them all. That structure is allocated one per memstick host, so its size doesn't matter.

* Add comments about few members of memstick_request

---
 include/linux/memstick.h |   50 ++++++++++++++++++++++++++++++++++-----------
 1 files changed, 38 insertions(+), 12 deletions(-)
include/linux/memstick.h +38 -12
index 690c35a..5479f7d 100644
@@ -45,14 +45,14 @@ struct ms_status_register {
 #define MEMSTICK_STATUS1_DTER 0x20
 #define MEMSTICK_STATUS1_FB1  0x40
 #define MEMSTICK_STATUS1_MB   0x80
-} __attribute__((packed));
+} __packed;
 
 struct ms_id_register {
 	unsigned char type;
 	unsigned char if_mode;
 	unsigned char category;
 	unsigned char class;
-} __attribute__((packed));
+} __packed;
 
 struct ms_param_register {
 	unsigned char system;
@@ -68,7 +68,7 @@ struct ms_param_register {
 #define MEMSTICK_CP_OVERWRITE 0x80
 
 	unsigned char page_address;
-} __attribute__((packed));
+} __packed;
 
 struct ms_extra_data_register {
 	unsigned char  overwrite_flag;
@@ -84,7 +84,7 @@ struct ms_extra_data_register {
 #define MEMSTICK_MANAGEMENT_SCMS0  0x20
 
 	unsigned short logical_address;
-} __attribute__((packed));
+} __packed;
 
 struct ms_register {
 	struct ms_status_register     status;
@@ -92,7 +92,7 @@ struct ms_register {
 	unsigned char                 reserved[8];
 	struct ms_param_register      param;
 	struct ms_extra_data_register extra_data;
-} __attribute__((packed));
+} __packed;
 
 struct mspro_param_register {
 	unsigned char  system;
@@ -103,7 +103,7 @@ struct mspro_param_register {
 	__be16 data_count;
 	__be32 data_address;
 	unsigned char  tpc_param;
-} __attribute__((packed));
+} __packed;
 
 struct mspro_io_info_register {
 	unsigned char version;
@@ -111,20 +111,28 @@ struct mspro_io_info_register {
 	unsigned char current_req;
 	unsigned char card_opt_info;
 	unsigned char rdy_wait_time;
-} __attribute__((packed));
+} __packed;
 
 struct mspro_io_func_register {
 	unsigned char func_enable;
 	unsigned char func_select;
 	unsigned char func_intmask;
 	unsigned char transfer_mode;
-} __attribute__((packed));
+} __packed;
 
 struct mspro_io_cmd_register {
 	unsigned short tpc_param;
 	unsigned short data_count;
 	unsigned int   data_address;
-} __attribute__((packed));
+} __packed;
+
+
+struct mspro_cmdex_argument {
+	unsigned char  command;
+	__be16 data_count;
+	__be32 data_address;
+} __packed;
+
 
 struct mspro_register {
 	struct ms_status_register     status;
@@ -138,14 +146,14 @@ struct mspro_register {
 	struct mspro_io_cmd_register  io_cmd;
 	unsigned char                 io_int;
 	unsigned char                 io_int_func;
-} __attribute__((packed));
+} __packed;
 
 struct ms_register_addr {
 	unsigned char r_offset;
 	unsigned char r_length;
 	unsigned char w_offset;
 	unsigned char w_length;
-} __attribute__((packed));
+} __packed;
 
 enum memstick_tpc {
 	MS_TPC_READ_MG_STATUS   = 0x01,
@@ -236,6 +244,24 @@ struct memstick_device_id {
 #define MEMSTICK_CLASS_WP             0x03
 };
 
+/* IO request that host driver gets from memtick core
+ *
+ * Note about the 'need_card_int' flag:
+
+ * In serial mode that flag _hints_ the host driver to wait till card
+ * raises the INT signal, so that core could spare sending redundant
+ * MS_TPC_GET_INT requests.
+ *
+ * In _parallel_ mode, that flag must be honored,
+ * and besides waiting, the host driver must read the INT register
+ * (via data lines)
+ *
+ * In addition to that if hardware is 'smart', and is able to read
+ * the INT register even in serial mode by sending MS_TPC_GET_INT
+ * by itself (This capablility is indicated by host via
+ * MEMSTICK_CAP_AUTO_GET_INT),
+ * then the serial mode behavier must match the parallel.
+ */
 struct memstick_request {
 	unsigned char tpc;
 	unsigned char data_dir:1,
@@ -247,7 +273,7 @@ struct memstick_request {
 		struct scatterlist sg;
 		struct {
 			unsigned char data_len;
-			unsigned char data[15];
+			unsigned char data[32];
 		};
 	};
 };
Signature · 1 line
1.7.1
maintainer
#2 lore raw

Re: [PATCH 01/29] memstick: core: header cleanups

Quoted 3 lines · Maxim Levitsky

Received: Friday, 22 October, 2010, 4:53 PM
* Replace the __attribute__((packed))
with __packed

This introduces unnecessary noise and can be merged into a common clean-up patch.

Quoted 8 lines

* Add struct mspro_cmdex_argument, argument for MS_TPC_EX_SET_CMD
* Increase size of inline buffer in memstick_request to 32 because thats the size of registers and someone might need to read them
all. That structure is allocated one per memstick host, so its size
doesn't matter.

This functional changes are better be joined with the first patch which actually requires them (these are just 4 lines).

Quoted 2 lines

* Add comments about few members of memstick_request

Belongs to the clean-up or a separate commenting patch.

Quoted 3 lines

---

author maintainer
#3 lore raw

Re: [PATCH 01/29] memstick: core: header cleanups

Quoted 8 lines · Alex Dubov
Quoted 3 lines · Maxim Levitsky

Received: Friday, 22 October, 2010, 4:53 PM
* Replace the __attribute__((packed))
with __packed

This introduces unnecessary noise and can be merged into a common clean-up patch.

And what value will that add?

Quoted 10 lines
Quoted 9 lines

* Add struct mspro_cmdex_argument, argument for MS_TPC_EX_SET_CMD
* Increase size of inline buffer in memstick_request to 32 because thats the size of registers and someone might need to read them
all. That structure is allocated one per memstick host, so its size
doesn't matter.

Quoted 2 lines

This functional changes are better be joined with the first patch which actually requires them (these are just 4 lines).

Not fully against that, but then what value will that add too? Currently memstick.h host many unused structures for MS IO stuff. And for god's sake it has MS_TPC_EX_SET_CMD declared,
so I just add the structure for its argument, whats wrong with doing that here?

Quoted 5 lines
Quoted 3 lines

* Add comments about few members of memstick_request

Belongs to the clean-up or a separate commenting patch.

Why?

As long as the patch is crearly readable I don't see a reason to add more patches.

Best regards,
Maxim Levitsky

author maintainer
#4 lore raw

PATCH 2/29 memstick: core: reorder functions This patch just reorders functions in memstick.c So that host specific and card driver specific functions are now grouped together. This makes it easier to understand the code.

In reply to Maxim Levitsky
---
 drivers/memstick/core/memstick.c |  293 ++++++++++++++++++++------------------
 include/linux/memstick.h         |   44 ++++---
 2 files changed, 184 insertions(+), 153 deletions(-)
drivers/memstick/core/memstick.c +157 -136
index c00fe82..5a501a4 100644
@@ -202,119 +202,6 @@ static int memstick_dummy_check(struct memstick_dev *card)
 	return 0;
 }
 
-/**
- * memstick_detect_change - schedule media detection on memstick host
- * @host - host to use
- */
-void memstick_detect_change(struct memstick_host *host)
-{
-	queue_work(workqueue, &host->media_checker);
-}
-EXPORT_SYMBOL(memstick_detect_change);
-
-/**
- * memstick_next_req - called by host driver to obtain next request to process
- * @host - host to use
- * @mrq - pointer to stick the request to
- *
- * Host calls this function from idle state (*mrq == NULL) or after finishing
- * previous request (*mrq should point to it). If previous request was
- * unsuccessful, it is retried for predetermined number of times. Return value
- * of 0 means that new request was assigned to the host.
- */
-int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
-{
-	int rc = -ENXIO;
-
-	if ((*mrq) && (*mrq)->error && host->retries) {
-		(*mrq)->error = rc;
-		host->retries--;
-		return 0;
-	}
-
-	if (host->card && host->card->next_request)
-		rc = host->card->next_request(host->card, mrq);
-
-	if (!rc)
-		host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
-	else
-		*mrq = NULL;
-
-	return rc;
-}
-EXPORT_SYMBOL(memstick_next_req);
-
-/**
- * memstick_new_req - notify the host that some requests are pending
- * @host - host to use
- */
-void memstick_new_req(struct memstick_host *host)
-{
-	if (host->card) {
-		host->retries = cmd_retries;
-		INIT_COMPLETION(host->card->mrq_complete);
-		host->request(host);
-	}
-}
-EXPORT_SYMBOL(memstick_new_req);
-
-/**
- * memstick_init_req_sg - set request fields needed for bulk data transfer
- * @mrq - request to use
- * @tpc - memstick Transport Protocol Command
- * @sg - TPC argument
- */
-void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
-			  const struct scatterlist *sg)
-{
-	mrq->tpc = tpc;
-	if (tpc & 8)
-		mrq->data_dir = WRITE;
-	else
-		mrq->data_dir = READ;
-
-	mrq->sg = *sg;
-	mrq->long_data = 1;
-
-	if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
-		mrq->need_card_int = 1;
-	else
-		mrq->need_card_int = 0;
-}
-EXPORT_SYMBOL(memstick_init_req_sg);
-
-/**
- * memstick_init_req - set request fields needed for short data transfer
- * @mrq - request to use
- * @tpc - memstick Transport Protocol Command
- * @buf - TPC argument buffer
- * @length - TPC argument size
- *
- * The intended use of this function (transfer of data items several bytes
- * in size) allows us to just copy the value between request structure and
- * user supplied buffer.
- */
-void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
-		       const void *buf, size_t length)
-{
-	mrq->tpc = tpc;
-	if (tpc & 8)
-		mrq->data_dir = WRITE;
-	else
-		mrq->data_dir = READ;
-
-	mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length;
-	if (mrq->data_dir == WRITE)
-		memcpy(mrq->data, buf, mrq->data_len);
-
-	mrq->long_data = 0;
-
-	if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
-		mrq->need_card_int = 1;
-	else
-		mrq->need_card_int = 0;
-}
-EXPORT_SYMBOL(memstick_init_req);
 
 /*
  * Functions prefixed with "h_" are protocol callbacks. They can be called from
@@ -362,20 +249,6 @@ static int h_memstick_set_rw_addr(struct memstick_dev *card,
 	}
 }
 
-/**
- * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
- *                        complete
- * @card - media device to use
- */
-int memstick_set_rw_addr(struct memstick_dev *card)
-{
-	card->next_request = h_memstick_set_rw_addr;
-	memstick_new_req(card->host);
-	wait_for_completion(&card->mrq_complete);
-
-	return card->current_mrq.error;
-}
-EXPORT_SYMBOL(memstick_set_rw_addr);
 
 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 {
@@ -418,7 +291,7 @@ err_out:
 	return NULL;
 }
 
-static int memstick_power_on(struct memstick_host *host)
+int memstick_power_on(struct memstick_host *host)
 {
 	int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
 
@@ -480,6 +353,125 @@ out_power_off:
 	dev_dbg(&host->dev, "memstick_check finished\n");
 }
 
+/*** card driver interface ***/
+
+/**
+  * memstick_register_driver - Register new card driver
+  * @drv - the driver descriptior
+  */
+
+int memstick_register_driver(struct memstick_driver *drv)
+{
+	drv->driver.bus = &memstick_bus_type;
+
+	return driver_register(&drv->driver);
+}
+EXPORT_SYMBOL(memstick_register_driver);
+
+/**
+  * memstick_unregister_driver - deregister new card driver
+  * @drv - the driver descriptior
+  */
+
+void memstick_unregister_driver(struct memstick_driver *drv)
+{
+	driver_unregister(&drv->driver);
+}
+EXPORT_SYMBOL(memstick_unregister_driver);
+
+
+/**
+ * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
+ *                        complete
+ * @card - media device to use
+ */
+int memstick_set_rw_addr(struct memstick_dev *card)
+{
+	card->next_request = h_memstick_set_rw_addr;
+	memstick_new_req(card->host);
+	wait_for_completion(&card->mrq_complete);
+
+	return card->current_mrq.error;
+}
+EXPORT_SYMBOL(memstick_set_rw_addr);
+
+
+
+
+/**
+ * memstick_new_req - notify the host that some requests are pending
+ * @host - host to use
+ */
+void memstick_new_req(struct memstick_host *host)
+{
+	if (host->card) {
+		host->retries = cmd_retries;
+		INIT_COMPLETION(host->card->mrq_complete);
+		host->request(host);
+	}
+}
+EXPORT_SYMBOL(memstick_new_req);
+
+/**
+ * memstick_init_req_sg - set request fields needed for bulk data transfer
+ * @mrq - request to use
+ * @tpc - memstick Transport Protocol Command
+ * @sg - TPC argument
+ */
+void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
+			  const struct scatterlist *sg)
+{
+	mrq->tpc = tpc;
+	if (tpc & 8)
+		mrq->data_dir = WRITE;
+	else
+		mrq->data_dir = READ;
+
+	mrq->sg = *sg;
+	mrq->long_data = 1;
+
+	if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
+		mrq->need_card_int = 1;
+	else
+		mrq->need_card_int = 0;
+}
+EXPORT_SYMBOL(memstick_init_req_sg);
+
+/**
+ * memstick_init_req - set request fields needed for short data transfer
+ * @mrq - request to use
+ * @tpc - memstick Transport Protocol Command
+ * @buf - TPC argument buffer
+ * @length - TPC argument size
+ *
+ * The intended use of this function (transfer of data items several bytes
+ * in size) allows us to just copy the value between request structure and
+ * user supplied buffer.
+ */
+void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
+		       const void *buf, size_t length)
+{
+	mrq->tpc = tpc;
+	if (tpc & 8)
+		mrq->data_dir = WRITE;
+	else
+		mrq->data_dir = READ;
+
+	mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length;
+	if (mrq->data_dir == WRITE)
+		memcpy(mrq->data, buf, mrq->data_len);
+
+	mrq->long_data = 0;
+
+	if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
+		mrq->need_card_int = 1;
+	else
+		mrq->need_card_int = 0;
+}
+EXPORT_SYMBOL(memstick_init_req);
+
+/*** low level (host) driver interface ***/
+
 /**
  * memstick_alloc_host - allocate a memstick_host structure
  * @extra: size of the user private data to allocate
@@ -597,19 +589,48 @@ void memstick_resume_host(struct memstick_host *host)
 }
 EXPORT_SYMBOL(memstick_resume_host);
 
-int memstick_register_driver(struct memstick_driver *drv)
-{
-	drv->driver.bus = &memstick_bus_type;
 
-	return driver_register(&drv->driver);
+/**
+ * memstick_detect_change - schedule media detection on memstick host
+ * @host - host to use
+ */
+void memstick_detect_change(struct memstick_host *host)
+{
+	queue_work(workqueue, &host->media_checker);
 }
-EXPORT_SYMBOL(memstick_register_driver);
+EXPORT_SYMBOL(memstick_detect_change);
 
-void memstick_unregister_driver(struct memstick_driver *drv)
+/**
+ * memstick_next_req - called by host driver to obtain next request to process
+ * @host - host to use
+ * @mrq - pointer to stick the request to
+ *
+ * Host calls this function from idle state (*mrq == NULL) or after finishing
+ * previous request (*mrq should point to it). If previous request was
+ * unsuccessful, it is retried for predetermined number of times. Return value
+ * of 0 means that new request was assigned to the host.
+ */
+int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
 {
-	driver_unregister(&drv->driver);
+	int rc = -ENXIO;
+
+	if ((*mrq) && (*mrq)->error && host->retries) {
+		(*mrq)->error = rc;
+		host->retries--;
+		return 0;
+	}
+
+	if (host->card && host->card->next_request)
+		rc = host->card->next_request(host->card, mrq);
+
+	if (!rc)
+		host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
+	else
+		*mrq = NULL;
+
+	return rc;
 }
-EXPORT_SYMBOL(memstick_unregister_driver);
+EXPORT_SYMBOL(memstick_next_req);
 
 
 static int __init memstick_init(void)
include/linux/memstick.h +27 -17

69 lines not on this page · raw message

Signature · 1 line
1.7.1
maintainer
#5 lore raw

Re: [PATCH 02/29] memstick: core: reorder functions This patch just reorders functions in memstick.c So that host specific and card driver specific functions are now grouped together. This makes it easier to understand the code.

Quoted 2 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 02/29] memstick: core: reorder functions This patch just reorders functions in memstick.c So that host specific and card driver specific functions are now grouped together. This makes it easier to understand the code.

I'm not sure this purely subjective patch is of any real utility. And at any rate, it belongs to the end of the patchset (where the clean-up normally go), not to the beginning.

author maintainer
#6 lore raw

Re: [PATCH 02/29] memstick: core: reorder functions This patch just reorders functions in memstick.c So that host specific and card driver specific functions are now grouped together. This makes it easier to understand the code.

Quoted 10 lines · Alex Dubov
Quoted 2 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 02/29] memstick: core: reorder functions This patch just reorders functions in memstick.c So that host specific and card driver specific functions are now grouped together. This makes it easier to understand the code.

I'm not sure this purely subjective patch is of any real utility. And at any rate, it belongs to the end of the patchset (where the clean-up normally go), not to the beginning.

Could somebody else comment on this?
I mean memstick.c/h contains two types of functions.
One is useful only for low level drivers, and other only for high level drivers. Whats wrong with at least grouping that together? It probably even better to put them to separate files...

As for doing that late, I exaplained that once in reply to Morton. It was much easier to split patches this way, and really doesn't matter otherwise.

Best regards,
Maxim Levitsky

author maintainer
#7 lore raw

PATCH 3/29 memstick: core: add new functions

In reply to Maxim Levitsky

Add a lot of support code that will be used later.

---
 drivers/memstick/core/memstick.c |  299 ++++++++++++++++++++++++++++++++++++--
 include/linux/memstick.h         |   32 ++++
 2 files changed, 318 insertions(+), 13 deletions(-)
drivers/memstick/core/memstick.c +286 -13
index 5a501a4..9fe36c7 100644
@@ -249,6 +249,17 @@ static int h_memstick_set_rw_addr(struct memstick_dev *card,
 	}
 }
 
+static int h_memstick_default_bad(struct memstick_dev *card,
+				     struct memstick_request **mrq)
+{
+	return -ENXIO;
+}
+
+static void memstick_invalidate_reg_window(struct memstick_dev *card)
+{
+	memset(&card->reg_addr, 0, sizeof(card->reg_addr));
+}
+
 
 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 {
@@ -293,14 +304,23 @@ err_out:
 
 int memstick_power_on(struct memstick_host *host)
 {
-	int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
+	int rc;
 
+	if (host->card)
+		memstick_invalidate_reg_window(host->card);
+
+	rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
 	if (!rc)
 		rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
 
 	return rc;
 }
 
+int memstick_power_off(struct memstick_host *host)
+{
+	return host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
+}
+
 static void memstick_check(struct work_struct *work)
 {
 	struct memstick_host *host = container_of(work, struct memstick_host,
@@ -347,7 +367,7 @@ static void memstick_check(struct work_struct *work)
 
 out_power_off:
 	if (!host->card)
-		host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
+		memstick_power_off(host);
 
 	mutex_unlock(&host->lock);
 	dev_dbg(&host->dev, "memstick_check finished\n");
@@ -356,10 +376,9 @@ out_power_off:
 /*** card driver interface ***/
 
 /**
-  * memstick_register_driver - Register new card driver
-  * @drv - the driver descriptior
-  */
-
+ * memstick_register_driver - register new card driver
+ * @drv - the driver info structure
+ */
 int memstick_register_driver(struct memstick_driver *drv)
 {
 	drv->driver.bus = &memstick_bus_type;
@@ -369,10 +388,10 @@ int memstick_register_driver(struct memstick_driver *drv)
 EXPORT_SYMBOL(memstick_register_driver);
 
 /**
-  * memstick_unregister_driver - deregister new card driver
-  * @drv - the driver descriptior
-  */
-
+ * memstick_unregister_driver - unregister a card driver
+ * usually called on card driver unload
+ * @drv - the driver info structure
+ */
 void memstick_unregister_driver(struct memstick_driver *drv)
 {
 	driver_unregister(&drv->driver);
@@ -396,8 +415,6 @@ int memstick_set_rw_addr(struct memstick_dev *card)
 EXPORT_SYMBOL(memstick_set_rw_addr);
 
 
-
-
 /**
  * memstick_new_req - notify the host that some requests are pending
  * @host - host to use
@@ -412,6 +429,93 @@ void memstick_new_req(struct memstick_host *host)
 }
 EXPORT_SYMBOL(memstick_new_req);
 
+
+/*** state machine support code ***/
+
+/**
+ * memstick_run_state_machine - runs IO state machine
+ * DON'T call from state machine code!
+ * Usefull for blocking IO in the card drivers.
+ * @card - card to use
+ * @state_func - the state machine
+ * @sync - if true, will wait till state machine exits using
+ * memstick_exit_state_machine
+ */
+int memstick_run_state_machine(struct memstick_dev *card,
+	int   (*state_func)(struct memstick_dev *card,
+			struct memstick_request **mrq), bool sync)
+{
+	WARN_ON(card->state != -1);
+
+	/* Init everything to prevent stale data from creeping in */
+	memset(&card->current_mrq, 0, sizeof(card->current_mrq));
+	card->int_polling = false;
+	card->state = 0;
+	card->exit_error = 0;
+
+
+	card->next_request = state_func;
+	card->host->retries = cmd_retries;
+	INIT_COMPLETION(card->mrq_complete);
+	card->host->request(card->host);
+
+	if (!sync)
+		return 0;
+
+	wait_for_completion(&card->mrq_complete);
+
+	WARN_ON(card->state != -1);
+	return card->exit_error;
+}
+EXPORT_SYMBOL(memstick_run_state_machine);
+
+
+/**
+ * memstick_exit_state_machine - signal that request is completed
+ * @card - card to use
+ * @mrq - request to use
+ * @error - result of the request
+ *
+ * State machines call this to signal quit
+ */
+int memstick_exit_state_machine(struct memstick_dev *card,
+			struct memstick_request *req, int error)
+{
+	if (error)
+		req->error = error;
+
+	card->state = -1;
+	card->exit_error = error;
+	card->next_request = h_memstick_default_bad;
+
+	/* Invalidate reg window on errors */
+	if (error)
+		memstick_invalidate_reg_window(card);
+
+	complete(&card->mrq_complete);
+	return -ENXIO;
+}
+EXPORT_SYMBOL(memstick_exit_state_machine);
+
+/**
+ * memstick_allocate_request - create new request for use in request handler
+ * @card - card to use
+ * @mrq - request to initialize
+ */
+void memstick_allocate_request(struct memstick_dev *card,
+					struct memstick_request **mrq)
+{
+	if (*mrq == NULL) {
+		*mrq = &card->current_mrq;
+		(*mrq)->error = 0;
+		(*mrq)->need_card_int = 0;
+		card->int_polling = false;
+		card->state = 0;
+	}
+}
+EXPORT_SYMBOL(memstick_allocate_request);
+
+
 /**
  * memstick_init_req_sg - set request fields needed for bulk data transfer
  * @mrq - request to use
@@ -470,6 +574,175 @@ void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
 }
 EXPORT_SYMBOL(memstick_init_req);
 
+/**
+ * memstick_read_int_reg - read INT status from the card
+ * if last request already contains the int flags, will return 0
+ * returns 1 if new request was initialized
+ * Will artifictially return MEMSTICK_INT_CMDNAK if more that 'timeout' msecs
+ * passed after last MS_TPC_GET_INT request (and no requests in between)
+ * if timeout == -1, then it is set to default value of 500 msec
+ * @card - card to use
+ * @timeout - the timeout. if -1, then uses default
+ */
+int memstick_read_int_reg(struct memstick_dev *card,
+				struct memstick_request *req, long timeout)
+{
+
+	if (!card->int_polling) {
+		card->int_timeout = jiffies +
+			msecs_to_jiffies(timeout == -1 ? 500 : timeout);
+		card->int_polling = true;
+	} else if (time_after(jiffies, card->int_timeout)) {
+		req->data[0] = MEMSTICK_INT_CMDNAK;
+		return 0;
+	}
+
+	if (((card->caps | card->host->caps) & MEMSTICK_CAP_AUTO_GET_INT) &&
+							req->need_card_int) {
+		BUG_ON(req->error);
+		req->data[0] = req->int_reg;
+		req->need_card_int = 0;
+		return 0;
+	} else {
+		memstick_init_req(req, MS_TPC_GET_INT, NULL, 1);
+		return 1;
+	}
+}
+EXPORT_SYMBOL(memstick_read_int_reg);
+
+
+/**
+ * memstick_read_int_reg_cleanup - cleanup after series of calls to
+ * memstick_read_int_reg. Used to cancel timeout.
+ * Use this if you use memstick_read_int_reg
+ * @card - card to use
+ */
+void memstick_read_int_reg_cleanup(struct memstick_dev *card)
+{
+	card->int_polling = false;
+}
+EXPORT_SYMBOL(memstick_read_int_reg_cleanup);
+
+
+/**
+ * memstick_read_regs - read the ms registers
+ * If there is need to change the R/W window,
+ * it will create the MS_TPC_SET_RW_REG_ADRS request and return 0,
+ * otherwise it will create a request for register read and return 1
+ * @card - card to use
+ * @offset - offset of first register to read
+ * @len - number of bytes to read
+ * @req - request to use
+ */
+
+int memstick_read_regs(struct memstick_dev *card, int offset, int len,
+	struct memstick_request *req)
+{
+	if (card->reg_addr.r_offset != offset ||
+					card->reg_addr.r_length != len) {
+		card->reg_addr.r_offset = offset;
+		card->reg_addr.r_length = len;
+
+		/* Set dummy window after reg invalidation to prevent
+			possible rejection of 0,0 window by the card */
+		if (!card->reg_addr.w_length) {
+			card->reg_addr.w_offset =
+					offsetof(struct ms_register, id);
+			card->reg_addr.w_length = sizeof(struct ms_id_register);
+		}
+
+		memstick_init_req(req, MS_TPC_SET_RW_REG_ADRS, &card->reg_addr,
+			sizeof(card->reg_addr));
+		return 0;
+	}
+
+	memstick_init_req(req, MS_TPC_READ_REG, NULL, len);
+	return 1;
+}
+EXPORT_SYMBOL(memstick_read_regs);
+
+/**
+ * memstick_write_regs - write the ms registers.
+ * If there is need to change the R/W window,
+ * it will create the MS_TPC_SET_RW_REG_ADRS request and return 0,
+ * otherwise it will create a request for register write and return 1
+ * @card - card to use
+ * @offset - offset of first register to read
+ * @len - number of bytes to read
+ * @buf - the register data to write
+ * @req - request to use
+ */
+int memstick_write_regs(struct memstick_dev *card, int offset, int len,
+	char *buf, struct memstick_request *req)
+{
+	if (card->reg_addr.w_offset != offset ||
+					card->reg_addr.w_length != len) {
+		card->reg_addr.w_offset = offset;
+		card->reg_addr.w_length = len;
+
+		/* Set dummy window after reg invalidation to prevent
+			possible rejection of 0,0 window by the card */
+		if (!card->reg_addr.r_length) {
+			card->reg_addr.r_offset =
+					offsetof(struct ms_register, id);
+
+			card->reg_addr.r_length = sizeof(struct ms_id_register);
+		}
+
+		memstick_init_req(req, MS_TPC_SET_RW_REG_ADRS, &card->reg_addr,
+			sizeof(card->reg_addr));
+		return 0;
+	}
+
+	memstick_init_req(req, MS_TPC_WRITE_REG, buf, len);
+	return 1;
+}
+EXPORT_SYMBOL(memstick_write_regs);
+
+
+static const char *tpc_names[] = {
+	"MS_TPC_READ_MG_STATUS",
+	"MS_TPC_READ_LONG_DATA",
+	"MS_TPC_READ_SHORT_DATA",
+	"MS_TPC_READ_REG",
+	"MS_TPC_READ_QUAD_DATA",
+	"INVALID",
+	"MS_TPC_GET_INT",
+	"MS_TPC_SET_RW_REG_ADRS",
+	"MS_TPC_EX_SET_CMD",
+	"MS_TPC_WRITE_QUAD_DATA",
+	"MS_TPC_WRITE_REG",
+	"MS_TPC_WRITE_SHORT_DATA",
+	"MS_TPC_WRITE_LONG_DATA",
+	"MS_TPC_SET_CMD",
+};
+
+/**
+ * memstick_debug_get_tpc_name - debug helper that returns string for
+ * a TPC number
+ */
+const char *memstick_debug_get_tpc_name(int tpc)
+{
+	return tpc_names[tpc-1];
+}
+EXPORT_SYMBOL(memstick_debug_get_tpc_name);
+
+/**
+ * memstick_reset - power cycles the host
+ */
+int memstick_reset(struct memstick_host *host)
+{
+	int error = memstick_power_off(host);
+	if (error)
+		return error;
+
+	/* TODO: why this delay ? */
+	msleep(50);
+
+	return memstick_power_on(host);
+}
+EXPORT_SYMBOL(memstick_reset);
+
 /*** low level (host) driver interface ***/
 
 /**
@@ -566,7 +839,7 @@ EXPORT_SYMBOL(memstick_free_host);
 void memstick_suspend_host(struct memstick_host *host)
 {
 	mutex_lock(&host->lock);
-	host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
+	memstick_power_off(host);
 	mutex_unlock(&host->lock);
 }
 EXPORT_SYMBOL(memstick_suspend_host);
include/linux/memstick.h +32 -0
index 428c4a1..73586cb 100644
@@ -296,6 +296,13 @@ struct memstick_dev {
 	void                     (*start)(struct memstick_dev *card);
 
 	struct device            dev;
+	int			 caps;
+
+	/* state machine's state */
+	int			 state;
+	int			 exit_error;
+	bool			 int_polling;
+	unsigned long		 int_timeout;
 };
 
 struct memstick_host {
@@ -349,6 +356,16 @@ void memstick_unregister_driver(struct memstick_driver *drv);
 
 int memstick_set_rw_addr(struct memstick_dev *card);
 
+int memstick_run_state_machine(struct memstick_dev *card,
+	int   (*state_func)(struct memstick_dev *card,
+			struct memstick_request **mrq), bool sync);
+
+int memstick_exit_state_machine(struct memstick_dev *card,
+			struct memstick_request *req, int error);
+
+void memstick_allocate_request(struct memstick_dev *card,
+					struct memstick_request **mrq);
+
 void memstick_new_req(struct memstick_host *host);
 
 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
@@ -356,6 +373,21 @@ void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
 		       const void *buf, size_t length);
 
+int memstick_read_int_reg(struct memstick_dev *card,
+				struct memstick_request *req, long timeout);
+
+void memstick_read_int_reg_cleanup(struct memstick_dev *card);
+
+int memstick_read_regs(struct memstick_dev *card, int offset, int len,
+	struct memstick_request *req);
+
+int memstick_write_regs(struct memstick_dev *card, int offset, int len,
+	char *buf, struct memstick_request *req);
+
+const char *memstick_debug_get_tpc_name(int tpc);
+
+int memstick_reset(struct memstick_host *host);
+
 /* Interface for low-level (host) drivers */
 
 struct memstick_host *memstick_alloc_host(unsigned int extra,
Signature · 1 line
1.7.1
maintainer
#8 lore raw

Re: [PATCH 03/29] memstick: core: add new functions

Quoted 8 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 03/29] memstick: core: add new functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Add a lot of support code that will
be used later.

You're adding here a lot of temporarily dead code, which, while being useful, should be better added together with the actual driver functionality.

Besides this, the patch has a lot of unneeded clean-ups which are better be set as a separate patch.

And it doesn't conform to the coding guideline either (4 byte indents, instead of tabs).

author maintainer
#9 lore raw

Re: [PATCH 03/29] memstick: core: add new functions

Quoted 11 lines · Alex Dubov
Quoted 8 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 03/29] memstick: core: add new functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Add a lot of support code that will
be used later.

Quoted 3 lines

You're adding here a lot of temporarily dead code, which, while being useful, should be better added together with the actual driver functionality.

So what?
What is wrong with that?
Why should I mix things together?

Quoted 3 lines

Besides this, the patch has a lot of unneeded clean-ups which are better be set as a separate patch.

What cleanups?
So I added the memstick_power_off and make code use it If you want even that as separate patch, ok.

And memstick_invalidate_reg_window in memstick_power_on? Again at any rate it will be invalid there.
(Maybe I should have put that in memstick_power_off actually, will do)

If you want me to put these changes in separate patches, ok, I do it.

Quoted 3 lines

And it doesn't conform to the coding guideline either (4 byte indents, instead of tab

What?
I checked the patch with checkpatch.pl. It didn't complain. I also use 8 byte tabs not 4.
Will look at that, thanks.

Best regards,
Maxim Levitsky

author maintainer
#10 lore raw

PATCH 4/29 memstick: core: rework state machines

In reply to Maxim Levitsky

Make state machines in memstick core follow the
new style.

---
 drivers/memstick/core/memstick.c |   82 ++++++++++++++++++++-----------------
 1 files changed, 44 insertions(+), 38 deletions(-)
drivers/memstick/core/memstick.c +44 -38
index 9fe36c7..e1aa089 100644
@@ -211,44 +211,57 @@ static int memstick_dummy_check(struct memstick_dev *card)
  */
 
 static int h_memstick_read_dev_id(struct memstick_dev *card,
-				  struct memstick_request **mrq)
+						struct memstick_request **mrq)
 {
 	struct ms_id_register id_reg;
 
-	if (!(*mrq)) {
-		memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, NULL,
-				  sizeof(struct ms_id_register));
-		*mrq = &card->current_mrq;
-		return 0;
-	} else {
-		if (!(*mrq)->error) {
-			memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
-			card->id.match_flags = MEMSTICK_MATCH_ALL;
-			card->id.type = id_reg.type;
-			card->id.category = id_reg.category;
-			card->id.class = id_reg.class;
-			dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
-		}
-		complete(&card->mrq_complete);
-		return -EAGAIN;
+	memstick_allocate_request(card, mrq);
+	if ((*mrq)->error)
+		return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
+
+	switch (card->state) {
+	case 0:
+		if (!memstick_read_regs(card,
+			offsetof(struct ms_register, id),
+			sizeof(struct ms_id_register), *mrq))
+			return 0;
+		break;
+	case 1:
+		memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
+		card->id.match_flags = MEMSTICK_MATCH_ALL;
+		card->id.type = id_reg.type;
+		card->id.category = id_reg.category;
+		card->id.class = id_reg.class;
+		dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
+		return memstick_exit_state_machine(card, *mrq, 0);
 	}
+
+	card->state++;
+	return 0;
 }
 
 static int h_memstick_set_rw_addr(struct memstick_dev *card,
 				  struct memstick_request **mrq)
 {
-	if (!(*mrq)) {
-		memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
+	memstick_allocate_request(card, mrq);
+	if ((*mrq)->error)
+		return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
+
+	switch (card->state) {
+	case 0:
+		memstick_init_req(*mrq, MS_TPC_SET_RW_REG_ADRS,
 				  (char *)&card->reg_addr,
 				  sizeof(card->reg_addr));
-		*mrq = &card->current_mrq;
-		return 0;
-	} else {
-		complete(&card->mrq_complete);
-		return -EAGAIN;
+		break;
+	case 1:
+		return memstick_exit_state_machine(card, *mrq, 0);
 	}
+
+	card->state++;
+	return 0;
 }
 
+
 static int h_memstick_default_bad(struct memstick_dev *card,
 				     struct memstick_request **mrq)
 {
@@ -281,18 +294,18 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 		card->reg_addr.w_offset = offsetof(struct ms_register, id);
 		card->reg_addr.w_length = sizeof(id_reg);
 
+		host->card = card;
 		init_completion(&card->mrq_complete);
+		card->state = -1;
+		card->next_request = h_memstick_default_bad;
 
-		host->card = card;
 		if (memstick_set_rw_addr(card))
 			goto err_out;
 
-		card->next_request = h_memstick_read_dev_id;
-		memstick_new_req(host);
-		wait_for_completion(&card->mrq_complete);
-
-		if (card->current_mrq.error)
+		if (memstick_run_state_machine(card,
+						h_memstick_read_dev_id, true))
 			goto err_out;
+
 	}
 	host->card = old_card;
 	return card;
@@ -406,11 +419,7 @@ EXPORT_SYMBOL(memstick_unregister_driver);
  */
 int memstick_set_rw_addr(struct memstick_dev *card)
 {
-	card->next_request = h_memstick_set_rw_addr;
-	memstick_new_req(card->host);
-	wait_for_completion(&card->mrq_complete);
-
-	return card->current_mrq.error;
+	return memstick_run_state_machine(card, h_memstick_set_rw_addr, true);
 }
 EXPORT_SYMBOL(memstick_set_rw_addr);
 
@@ -481,9 +490,6 @@ EXPORT_SYMBOL(memstick_run_state_machine);
 int memstick_exit_state_machine(struct memstick_dev *card,
 			struct memstick_request *req, int error)
 {
-	if (error)
-		req->error = error;
-
 	card->state = -1;
 	card->exit_error = error;
 	card->next_request = h_memstick_default_bad;
Signature · 1 line
1.7.1
maintainer
#11 lore raw

Re: [PATCH 04/29] memstick: core: rework state machines

Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 04/29] memstick: core: rework state machines
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Make state machines in memstick core
follow the
new style.

1. This is an important functional patch. At present, "new style" exists only in your head. You should make an effort to justify it to everybody else by providing a rationale in patch description.

2. You are using an integer state variable (instead of function pointers which were self-describing by virtue of the referred function names). Please, define an enumerated type for this state variable, giving states human-readable, descriptive names. If you need to do state variable arithmetic, you can provide a couple of simple, descriptive macros to do so:

#define NEXT_STATE(s) (s + 1)

or something along the line.

3. Coding style.

author maintainer
#12 lore raw

Re: [PATCH 04/29] memstick: core: rework state machines

Quoted 12 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 04/29] memstick: core: rework state machines
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Make state machines in memstick core
follow the
new style.

Quoted 3 lines

1. This is an important functional patch. At present, "new style" exists only in your head. You should make an effort to justify it to everybody else by providing a rationale in patch description.

I already explained that.
Ok. I add that explanation to patch header.

Quoted 9 lines

2. You are using an integer state variable (instead of function pointers which were self-describing by virtue of the referred function names). Please, define an enumerated type for this state variable, giving states human-readable, descriptive names. If you need to do state variable arithmetic, you can provide a couple of simple, descriptive macros to do so:

#define NEXT_STATE(s) (s + 1)

Do we have a corporate policy of no magic numbers?
Like this: http://thedailywtf.com/Articles/Avoiding-Magic-Constants.aspx

The issue here (I explained it already) is that I often use card-state ++; to get to next state;
Other the enforcing the policy the suggested #define it won't help.

card->state++ allows me for example to fallback through switch states and go by default to next state by default without additional code. If I bury state numbers with #defines or enums, the assumptions that states appear in switch in ascending order won't be obvious anymore and nether that adding 1 to state will bring me to next switch case.

Quoted 4 lines

or something along the line.

3. Coding style.

Passed checkpatch.pl. Could you show me the lines affected?

Best regards,
Maxim Levitsky

author maintainer
#13 lore raw

PATCH 5/29 memstick: mspro_block: move declarations to header and refactor things a bit

In reply to Maxim Levitsky

This makes it much easier to lookup things and reduces size of mspro_block.c Also add debbuging macros so that it becames possible to control debbuging via module param.

---
 drivers/memstick/core/mspro_block.c |  157 ++-----------------------------
 drivers/memstick/core/mspro_block.h |  176 +++++++++++++++++++++++++++++++++++
 2 files changed, 185 insertions(+), 148 deletions(-)
 create mode 100644 drivers/memstick/core/mspro_block.h
drivers/memstick/core/mspro_block.c +9 -148
index d3f1a08..5dc8fd7 100644
@@ -20,158 +20,14 @@
 #include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/memstick.h>
-
-#define DRIVER_NAME "mspro_block"
+#include "mspro_block.h"
 
 static int major;
-module_param(major, int, 0644);
-
-#define MSPRO_BLOCK_MAX_SEGS  32
-#define MSPRO_BLOCK_MAX_PAGES ((2 << 16) - 1)
-
-#define MSPRO_BLOCK_SIGNATURE        0xa5c3
-#define MSPRO_BLOCK_MAX_ATTRIBUTES   41
-
-#define MSPRO_BLOCK_PART_SHIFT 3
-
-enum {
-	MSPRO_BLOCK_ID_SYSINFO         = 0x10,
-	MSPRO_BLOCK_ID_MODELNAME       = 0x15,
-	MSPRO_BLOCK_ID_MBR             = 0x20,
-	MSPRO_BLOCK_ID_PBR16           = 0x21,
-	MSPRO_BLOCK_ID_PBR32           = 0x22,
-	MSPRO_BLOCK_ID_SPECFILEVALUES1 = 0x25,
-	MSPRO_BLOCK_ID_SPECFILEVALUES2 = 0x26,
-	MSPRO_BLOCK_ID_DEVINFO         = 0x30
-};
-
-struct mspro_sys_attr {
-	size_t                  size;
-	void                    *data;
-	unsigned char           id;
-	char                    name[32];
-	struct device_attribute dev_attr;
-};
-
-struct mspro_attr_entry {
-	__be32 address;
-	__be32 size;
-	unsigned char id;
-	unsigned char reserved[3];
-} __attribute__((packed));
-
-struct mspro_attribute {
-	__be16 signature;
-	unsigned short          version;
-	unsigned char           count;
-	unsigned char           reserved[11];
-	struct mspro_attr_entry entries[];
-} __attribute__((packed));
-
-struct mspro_sys_info {
-	unsigned char  class;
-	unsigned char  reserved0;
-	__be16 block_size;
-	__be16 block_count;
-	__be16 user_block_count;
-	__be16 page_size;
-	unsigned char  reserved1[2];
-	unsigned char  assembly_date[8];
-	__be32 serial_number;
-	unsigned char  assembly_maker_code;
-	unsigned char  assembly_model_code[3];
-	__be16 memory_maker_code;
-	__be16 memory_model_code;
-	unsigned char  reserved2[4];
-	unsigned char  vcc;
-	unsigned char  vpp;
-	__be16 controller_number;
-	__be16 controller_function;
-	__be16 start_sector;
-	__be16 unit_size;
-	unsigned char  ms_sub_class;
-	unsigned char  reserved3[4];
-	unsigned char  interface_type;
-	__be16 controller_code;
-	unsigned char  format_type;
-	unsigned char  reserved4;
-	unsigned char  device_type;
-	unsigned char  reserved5[7];
-	unsigned char  mspro_id[16];
-	unsigned char  reserved6[16];
-} __attribute__((packed));
-
-struct mspro_mbr {
-	unsigned char boot_partition;
-	unsigned char start_head;
-	unsigned char start_sector;
-	unsigned char start_cylinder;
-	unsigned char partition_type;
-	unsigned char end_head;
-	unsigned char end_sector;
-	unsigned char end_cylinder;
-	unsigned int  start_sectors;
-	unsigned int  sectors_per_partition;
-} __attribute__((packed));
-
-struct mspro_specfile {
-	char           name[8];
-	char           ext[3];
-	unsigned char  attr;
-	unsigned char  reserved[10];
-	unsigned short time;
-	unsigned short date;
-	unsigned short cluster;
-	unsigned int   size;
-} __attribute__((packed));
-
-struct mspro_devinfo {
-	__be16 cylinders;
-	__be16 heads;
-	__be16 bytes_per_track;
-	__be16 bytes_per_sector;
-	__be16 sectors_per_track;
-	unsigned char  reserved[6];
-} __attribute__((packed));
-
-struct mspro_block_data {
-	struct memstick_dev   *card;
-	unsigned int          usage_count;
-	unsigned int          caps;
-	struct gendisk        *disk;
-	struct request_queue  *queue;
-	struct request        *block_req;
-	spinlock_t            q_lock;
-
-	unsigned short        page_size;
-	unsigned short        cylinders;
-	unsigned short        heads;
-	unsigned short        sectors_per_track;
-
-	unsigned char         system;
-	unsigned char         read_only:1,
-			      eject:1,
-			      has_request:1,
-			      data_dir:1,
-			      active:1;
-	unsigned char         transfer_cmd;
-
-	int                   (*mrq_handler)(struct memstick_dev *card,
-					     struct memstick_request **mrq);
-
-	struct attribute_group attr_group;
-
-	struct scatterlist    req_sg[MSPRO_BLOCK_MAX_SEGS];
-	unsigned int          seg_count;
-	unsigned int          current_seg;
-	unsigned int          current_page;
-};
+static int debug;
 
 static DEFINE_IDR(mspro_block_disk_idr);
 static DEFINE_MUTEX(mspro_block_disk_lock);
 
-static int mspro_block_complete_req(struct memstick_dev *card, int error);
-
 /*** Block device ***/
 
 static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
@@ -1202,6 +1058,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 	msb->cylinders = be16_to_cpu(dev_info->cylinders);
 	msb->heads = be16_to_cpu(dev_info->heads);
 	msb->sectors_per_track = be16_to_cpu(dev_info->sectors_per_track);
+	sg_init_table(msb->req_sg, MSPRO_BLOCK_MAX_SEGS);
 
 	msb->page_size = be16_to_cpu(sys_info->unit_size);
 
@@ -1257,7 +1114,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 	capacity *= be16_to_cpu(sys_info->block_size);
 	capacity *= msb->page_size >> 9;
 	set_capacity(msb->disk, capacity);
-	dev_dbg(&card->dev, "capacity set %ld\n", capacity);
+	dbg(card, "capacity set %ld", capacity);
 
 	add_disk(msb->disk);
 	msb->active = 1;
@@ -1345,7 +1202,7 @@ static void mspro_block_remove(struct memstick_dev *card)
 	spin_unlock_irqrestore(&msb->q_lock, flags);
 
 	del_gendisk(msb->disk);
-	dev_dbg(&card->dev, "mspro block remove\n");
+	dbg(card, "mspro block remove");
 
 	blk_cleanup_queue(msb->queue);
 	msb->queue = NULL;
@@ -1485,6 +1342,10 @@ static void __exit mspro_block_exit(void)
 module_init(mspro_block_init);
 module_exit(mspro_block_exit);
 
+module_param(major, int, 0644);
+module_param(debug, int, 0644);
+
+
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Alex Dubov");
 MODULE_DESCRIPTION("Sony MemoryStickPro block device driver");
drivers/memstick/core/mspro_block.h new file +176 -0

176 lines not on this page · raw message

Signature · 1 line
1.7.1
maintainer
#14 lore raw

Re: [PATCH 05/29] memstick: mspro_block: move declarations to header and refactor things a bit

Quoted 7 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 05/29] memstick: mspro_block: move declarations to header and refactor things a bit
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This makes it much easier to lookup
things and reduces size of mspro_block.c

Subjective and irrelevant.
My editor makes it easier to look up things when they are in the same file, and this declarations are not expected to be used by any other compilation unit. Belongs to the cosmetic category which should be discussed later.

Quoted 4 lines

Also add debbuging macros so that it becames possible to control
debbuging via module param.

Should be done through a common kernel infrastructure, namely DYNAMIC_DEBUG feature (pr_debug and friends).

author maintainer
#15 lore raw

Re: [PATCH 05/29] memstick: mspro_block: move declarations to header and refactor things a bit

Quoted 10 lines · Alex Dubov
Quoted 7 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 05/29] memstick: mspro_block: move declarations to header and refactor things a bit
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This makes it much easier to lookup
things and reduces size of mspro_block.c

Quoted 4 lines

Subjective and irrelevant.
My editor makes it easier to look up things when they are in the same file, and this declarations are not expected to be used by any other compilation unit. Belongs to the cosmetic category which should be discussed later.

I agree that it is subjective.
However when you have 2 files, you can always open them in different copies of an editor, terminal tabs.
When you have decorations in one file you depend on the editor a lot. also its not about finding them.
Its about distrupting the workflow, because once you find the declaration you need to find the place you were before.
I understand that some editors help with that, yea.

Quoted 8 lines
Quoted 5 lines

Also add debbuging macros so that it becames possible to control
debbuging via module param.

Should be done through a common kernel infrastructure, namely DYNAMIC_DEBUG feature (pr_debug and friends).

How a user can turn DYNAMIC_DEBUG on?
How about different levels of verbosity?
Last time I checked DYNAMIC_DEBUG doesn't allow that. Besides the macros I add revert to
DYNAMIC_DEBUG if user doesn't specify the debug= module param.

When dynamic debugs grows that features (I have seen a ddebug= patchset, hope it gets merged, I will just trim down these macros). Besides the goal of these macros is to reduce typing.
I need to add/remove the debug printouts very often, and then I don't want even to type that '\n' at the end.
Besides, a lot of drivers are doing that. Just look around.

I already added similiar looking macros to 2 my other driver
(r852 sm_ftls and ene_cir) and no complains.

Best regards,
Maxim Levitsky

author maintainer
#16 lore raw

PATCH 6/29 memstick: mspro: kill the BKL

In reply to Maxim Levitsky

mspro_block_disk_lock already protects the code.

---
 drivers/memstick/core/mspro_block.c |    6 ------
 1 files changed, 0 insertions(+), 6 deletions(-)
drivers/memstick/core/mspro_block.c +0 -6
index 5dc8fd7..a979c9d 100644
@@ -36,7 +36,6 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
 	struct mspro_block_data *msb = disk->private_data;
 	int rc = -ENXIO;
 
-	lock_kernel();
 	mutex_lock(&mspro_block_disk_lock);
 
 	if (msb && msb->card) {
@@ -48,8 +47,6 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
 	}
 
 	mutex_unlock(&mspro_block_disk_lock);
-	unlock_kernel();
-
 	return rc;
 }
 
@@ -74,16 +71,13 @@ static int mspro_block_disk_release(struct gendisk *disk)
 	}
 
 	mutex_unlock(&mspro_block_disk_lock);
-
 	return 0;
 }
 
 static int mspro_block_bd_release(struct gendisk *disk, fmode_t mode)
 {
 	int ret;
-	lock_kernel();
 	ret = mspro_block_disk_release(disk);
-	unlock_kernel();
 	return ret;
 }
 
Signature · 1 line
1.7.1
maintainer
#17 lore raw

Re: [PATCH 06/29] memstick: mspro: kill the BKL

Quoted 8 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 06/29] memstick: mspro: kill the BKL
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
mspro_block_disk_lock already
protects the code.

It is indeed, but I don't see the functionality this patch is trying to revert neither in my running kernel (2.6.32.8) nor in current git tree.

author maintainer
#18 lore raw

Re: [PATCH 06/29] memstick: mspro: kill the BKL

Quoted 12 lines · Alex Dubov
Quoted 8 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 06/29] memstick: mspro: kill the BKL
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
mspro_block_disk_lock already
protects the code.

Quoted 2 lines

It is indeed, but I don't see the functionality this patch is trying to revert neither in my running kernel (2.6.32.8) nor in current git tree.

This patch is against 2.6.35 which moved BKL from core to drivers so that maintainers could take action.
Actually due to lack of action from memstick maintainers, this patch doesn't apply to mainline as now BKL is replaced with yet another unnecessary mutex.
I have a patch to remove it.

Best regards,
Maxim Levitsky

author maintainer
#19 lore raw

PATCH 7/29 memstick: mspro: two fixes

In reply to Maxim Levitsky

fix uninitialized spinlock warning on resume
and race in idr_pre_get

---
 drivers/memstick/core/mspro_block.c |   10 ++++++++--
 1 files changed, 8 insertions(+), 2 deletions(-)
drivers/memstick/core/mspro_block.c +8 -2
index a979c9d..13cb83b 100644
@@ -485,6 +485,7 @@ has_int_reg:
 		t_offset = msb->req_sg[msb->current_seg].offset;
 		t_offset += msb->current_page * msb->page_size;
 
+		sg_init_table(&t_sg, 1);
 		sg_set_page(&t_sg,
 			    nth_page(sg_page(&(msb->req_sg[msb->current_seg])),
 				     t_offset >> PAGE_SHIFT),
@@ -1056,10 +1057,13 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 
 	msb->page_size = be16_to_cpu(sys_info->unit_size);
 
-	if (!idr_pre_get(&mspro_block_disk_idr, GFP_KERNEL))
+	mutex_lock(&mspro_block_disk_lock);
+
+	if (!idr_pre_get(&mspro_block_disk_idr, GFP_KERNEL)) {
+		mutex_unlock(&mspro_block_disk_lock);
 		return -ENOMEM;
+	}
 
-	mutex_lock(&mspro_block_disk_lock);
 	rc = idr_get_new(&mspro_block_disk_idr, card, &disk_id);
 	mutex_unlock(&mspro_block_disk_lock);
 
@@ -1248,6 +1252,8 @@ static int mspro_block_resume(struct memstick_dev *card)
 
 	new_msb->card = card;
 	memstick_set_drvdata(card, new_msb);
+	spin_lock_init(&new_msb->q_lock);
+
 	if (mspro_block_init_card(card))
 		goto out_free;
 
Signature · 1 line
1.7.1
maintainer
#20 lore raw

Re: [PATCH 07/29] memstick: mspro: two fixes

Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 07/29] memstick: mspro: two fixes
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
fix uninitialized spinlock warning on
resume
and race in idr_pre_get

I fully agree.

Coding style!

author maintainer
#21 lore raw

Re: [PATCH 07/29] memstick: mspro: two fixes

Quoted 13 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 07/29] memstick: mspro: two fixes
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
fix uninitialized spinlock warning on
resume
and race in idr_pre_get

Quoted 3 lines

I fully agree.

Coding style!

Passed checkpatch.pl.

Signature · 2 lines
Best regards,
        Maxim Levitsky
author maintainer
#22 lore raw

PATCH 8/29 memstick: mspro: add comments to few functions

In reply to Maxim Levitsky

a comment before function is not only a good way to give some information to the reader, but it serves as a good anchor point for diff so that it doesn't produce a diff between different functions (sigh...)

---
 drivers/memstick/core/mspro_block.c |   14 ++++++++++++++
 1 files changed, 14 insertions(+), 0 deletions(-)
drivers/memstick/core/mspro_block.c +14 -0
index 13cb83b..a7f263d 100644
@@ -515,6 +515,10 @@ has_int_reg:
 
 /*** Data transfer ***/
 
+/*
+ * Start execution of next block request,
+ * or continue execution of the current one
+ */
 static int mspro_block_issue_req(struct memstick_dev *card, int chunk)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
@@ -575,6 +579,11 @@ try_again:
 	goto try_again;
 }
 
+/*
+ * Completes execution of current block request.
+ *  After execution of this function, the msb->block_req might or might not
+ *  be NULL. If it is, it means we don't have any more requests to process
+ */
 static int mspro_block_complete_req(struct memstick_dev *card, int error)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
@@ -630,6 +639,10 @@ out:
 	return error;
 }
 
+/*
+ * This pauses driver.
+ * Makes sure that driver won't send any commands to the device
+ */
 static void mspro_block_stop(struct memstick_dev *card)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
@@ -651,6 +664,7 @@ static void mspro_block_stop(struct memstick_dev *card)
 	}
 }
 
+/* This undoes effects of mspro_block_stop */
 static void mspro_block_start(struct memstick_dev *card)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
Signature · 1 line
1.7.1
maintainer
#23 lore raw

Re: [PATCH 08/29] memstick: mspro: add comments to few functions

Quoted 12 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 08/29] memstick: mspro: add comments to few functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
a comment before function is not only
a good way
to give some information to the reader, but
it serves as a good anchor point for diff so that
it doesn't produce a diff between different
functions (sigh...)

Comments of new functions belong to the patch which introduces these new functions. And those functions (as I already said) belong to the patch which introduces new functionality, using these functions, desirably, one function at a time.

author maintainer
#24 lore raw

Re: [PATCH 08/29] memstick: mspro: add comments to few functions

Quoted 15 lines · Alex Dubov
Quoted 12 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 08/29] memstick: mspro: add comments to few functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
a comment before function is not only
a good way
to give some information to the reader, but
it serves as a good anchor point for diff so that
it doesn't produce a diff between different
functions (sigh...)

Quoted 4 lines

Comments of new functions belong to the patch which introduces these new functions. And those functions (as I already said) belong to the patch which introduces new functionality, using these functions, desirably, one function at a time.

You did read the patch didn't you?
I added few comments to _existing_ functions something that code really needs.
I also did explain why did I do that here, didn't I?
It makes next patch cleaner, as diff doesn't attempt to create a diff between different functions.

Signature · 2 lines
Best regards,
        Maxim Levitsky
author maintainer
#25 lore raw

PATCH 9/29 memstick: rework state machines + attribute read function

In reply to Maxim Levitsky

Code is rewritten to use new style of state machines. Attribute read function is cleaned up and commented sparsely.

---
 drivers/memstick/core/mspro_block.c |  570 +++++++++++++++++------------------
 drivers/memstick/core/mspro_block.h |   67 +++--
 2 files changed, 319 insertions(+), 318 deletions(-)
drivers/memstick/core/mspro_block.c +284 -286
index a7f263d..cf98fa8 100644
@@ -385,14 +385,9 @@ static int h_mspro_block_req_init(struct memstick_dev *card,
 static int h_mspro_block_default(struct memstick_dev *card,
 				 struct memstick_request **mrq)
 {
-	return mspro_block_complete_req(card, (*mrq)->error);
+	return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
 }
 
-static int h_mspro_block_default_bad(struct memstick_dev *card,
-				     struct memstick_request **mrq)
-{
-	return -ENXIO;
-}
 
 static int h_mspro_block_get_ro(struct memstick_dev *card,
 				struct memstick_request **mrq)
@@ -407,7 +402,7 @@ static int h_mspro_block_get_ro(struct memstick_dev *card,
 			msb->read_only = 0;
 	}
 
-	return mspro_block_complete_req(card, (*mrq)->error);
+	return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
 }
 
 static int h_mspro_block_wait_for_ced(struct memstick_dev *card,
@@ -422,95 +417,146 @@ static int h_mspro_block_wait_for_ced(struct memstick_dev *card,
 			return 0;
 	}
 
-	return mspro_block_complete_req(card, (*mrq)->error);
+	return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
 }
 
 static int h_mspro_block_transfer_data(struct memstick_dev *card,
 				       struct memstick_request **mrq)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
-	unsigned char t_val = 0;
+	unsigned char intreg = 0, command;
 	struct scatterlist t_sg = { 0 };
+	unsigned long flags;
+	int error;
 	size_t t_offset;
 
-	if ((*mrq)->error)
-		return mspro_block_complete_req(card, (*mrq)->error);
+	memstick_allocate_request(card, mrq);
 
-	switch ((*mrq)->tpc) {
-	case MS_TPC_WRITE_REG:
-		memstick_init_req(*mrq, MS_TPC_SET_CMD, &msb->transfer_cmd, 1);
-		(*mrq)->need_card_int = 1;
-		return 0;
-	case MS_TPC_SET_CMD:
-		t_val = (*mrq)->int_reg;
-		memstick_init_req(*mrq, MS_TPC_GET_INT, NULL, 1);
-		if (msb->caps & MEMSTICK_CAP_AUTO_GET_INT)
-			goto has_int_reg;
-		return 0;
-	case MS_TPC_GET_INT:
-		t_val = (*mrq)->data[0];
-has_int_reg:
-		if (t_val & (MEMSTICK_INT_CMDNAK | MEMSTICK_INT_ERR)) {
-			t_val = MSPRO_CMD_STOP;
-			memstick_init_req(*mrq, MS_TPC_SET_CMD, &t_val, 1);
-			card->next_request = h_mspro_block_default;
+	if ((*mrq)->error) {
+		dbg(card, "IO: error (%d) executing %s", (*mrq)->error,
+			memstick_debug_get_tpc_name((*mrq)->tpc));
+
+		if (!msb->io_error) {
+			msb->io_error = (*mrq)->error;
+			card->state = 6;
+		}
+	}
+again:
+	switch (card->state) {
+
+	case 0: /* send read/write command + args */
+		if (!memstick_write_regs(card,
+			offsetof(struct mspro_register, param),
+			sizeof(struct mspro_param_register),
+			(unsigned char *)&msb->arg, *mrq))
 			return 0;
+		break;
+	case 1:
+		memstick_init_req(*mrq, MS_TPC_SET_CMD,
+					&msb->transfer_cmd, 1);
+		break;
+
+	case 2: /* read the INT register */
+		if (memstick_read_int_reg(card, *mrq, -1))
+			break;
+		card->state++;
+
+	case 3: /* process the int register */
+		intreg = (*mrq)->data[0];
+
+		if (intreg & (MEMSTICK_INT_CMDNAK | MEMSTICK_INT_ERR)) {
+			dbg(card, "IO: card I/O error");
+			card->state = 6;
+			msb->io_error = -EIO;
+			goto again;
 		}
 
-		if (msb->current_page
-		    == (msb->req_sg[msb->current_seg].length
-			/ msb->page_size)) {
-			msb->current_page = 0;
-			msb->current_seg++;
-
-			if (msb->current_seg == msb->seg_count) {
-				if (t_val & MEMSTICK_INT_CED) {
-					return mspro_block_complete_req(card,
-									0);
-				} else {
-					card->next_request
-						= h_mspro_block_wait_for_ced;
-					memstick_init_req(*mrq, MS_TPC_GET_INT,
-							  NULL, 1);
-					return 0;
-				}
+		/* we need CED for last page */
+		if (!msb->current_sg) {
+			if (!(intreg & MEMSTICK_INT_CED)) {
+				card->state--;
+				goto again;
 			}
+
+			memstick_read_int_reg_cleanup(card);
+			card->state = 7;
+			goto again;
 		}
 
-		if (!(t_val & MEMSTICK_INT_BREQ)) {
-			memstick_init_req(*mrq, MS_TPC_GET_INT, NULL, 1);
-			return 0;
+		/* And BREQ for non last... */
+		if (!(intreg & MEMSTICK_INT_BREQ)) {
+			card->state--;
+			goto again;
 		}
 
-		t_offset = msb->req_sg[msb->current_seg].offset;
-		t_offset += msb->current_page * msb->page_size;
+		memstick_read_int_reg_cleanup(card);
+		card->state++;
+
+	case 4: /* init transfer of the data */
+		t_offset = msb->current_sg->offset + msb->current_sg_offset;
 
 		sg_init_table(&t_sg, 1);
-		sg_set_page(&t_sg,
-			    nth_page(sg_page(&(msb->req_sg[msb->current_seg])),
-				     t_offset >> PAGE_SHIFT),
-			    msb->page_size, offset_in_page(t_offset));
-
-		memstick_init_req_sg(*mrq, msb->data_dir == READ
-					   ? MS_TPC_READ_LONG_DATA
-					   : MS_TPC_WRITE_LONG_DATA,
-				     &t_sg);
+		sg_set_page(&t_sg, nth_page(sg_page(msb->current_sg),
+			t_offset >> PAGE_SHIFT), msb->page_size,
+			offset_in_page(t_offset));
+
+		memstick_init_req_sg(*mrq, msb->data_dir == READ ?
+			MS_TPC_READ_LONG_DATA : MS_TPC_WRITE_LONG_DATA, &t_sg);
 		(*mrq)->need_card_int = 1;
-		return 0;
-	case MS_TPC_READ_LONG_DATA:
-	case MS_TPC_WRITE_LONG_DATA:
-		msb->current_page++;
-		if (msb->caps & MEMSTICK_CAP_AUTO_GET_INT) {
-			t_val = (*mrq)->int_reg;
-			goto has_int_reg;
-		} else {
-			memstick_init_req(*mrq, MS_TPC_GET_INT, NULL, 1);
-			return 0;
+		break;
+
+	case 5: /* switch to next page */
+		msb->current_sg_offset += msb->page_size;
+		msb->data_transferred += msb->page_size;
+
+		if (msb->current_sg_offset == msb->current_sg->length) {
+			msb->current_sg_offset = 0;
+			msb->current_sg = sg_next(msb->current_sg);
 		}
 
+		card->state = 2;
+		goto again;
+
+	case 6: /* after a error send STOP command */
+		command = MSPRO_CMD_STOP;
+		memstick_init_req(*mrq, MS_TPC_SET_CMD, &command, 1);
+		break;
+
+	case 7: /* request complete - get next one*/
+		spin_lock_irqsave(&msb->q_lock, flags);
+
+		if (msb->io_error)
+			(*mrq)->error = msb->io_error;
+
+		if (msb->block_req) {
+			mspro_block_complete_req(card, (*mrq)->error);
+			error = mspro_block_issue_req(card, false);
+
+			if (!msb->block_req) {
+				dbg_v(card, "IO: out of requests");
+				error = memstick_exit_state_machine(
+						card, *mrq, (*mrq)->error);
+				spin_unlock_irqrestore(&msb->q_lock, flags);
+				return error;
+			}
+
+			spin_unlock_irqrestore(&msb->q_lock, flags);
+			(*mrq)->error = 0;
+			card->state = 0;
+			goto again;
+
+		} else {
+			error = memstick_exit_state_machine(card,
+							*mrq, (*mrq)->error);
+			spin_unlock_irqrestore(&msb->q_lock, flags);
+			return error;
+		}
 	default:
 		BUG();
 	}
+
+	card->state++;
+	return 0;
 }
 
 /*** Data transfer ***/
@@ -519,64 +565,62 @@ has_int_reg:
  * Start execution of next block request,
  * or continue execution of the current one
  */
-static int mspro_block_issue_req(struct memstick_dev *card, int chunk)
+static int mspro_block_issue_req(struct memstick_dev *card, bool first)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
-	sector_t t_sec;
-	unsigned int count;
-	struct mspro_param_register param;
-
-try_again:
-	while (chunk) {
-		msb->current_page = 0;
-		msb->current_seg = 0;
-		msb->seg_count = blk_rq_map_sg(msb->block_req->q,
-					       msb->block_req,
-					       msb->req_sg);
-
-		if (!msb->seg_count) {
-			chunk = __blk_end_request_cur(msb->block_req, -ENOMEM);
-			continue;
+	sector_t sec;
+	bool is_read;
+	unsigned int pages;
+again:
+	/* get next request from block core if we don't have one */
+	if (!msb->block_req) {
+		dbg(card, "IO: fetching new request from block queue");
+		msb->block_req = blk_fetch_request(msb->queue);
+		if (!msb->block_req) {
+			dbg(card, "IO: failed, because queue is empty");
+			return -ENXIO;
 		}
+	}
 
-		t_sec = blk_rq_pos(msb->block_req) << 9;
-		sector_div(t_sec, msb->page_size);
+	if (msb->eject) {
+		dbg(card, "IO: Refusing request, because card is removed");
+		__blk_end_request_all(msb->block_req, -ENODEV);
+		msb->block_req = NULL;
+		goto again;
+	}
 
-		count = blk_rq_bytes(msb->block_req);
-		count /= msb->page_size;
+	sec = blk_rq_pos(msb->block_req) << 9;
+	sector_div(sec, msb->page_size);
+	pages = blk_rq_bytes(msb->block_req) / msb->page_size;
 
-		param.system = msb->system;
-		param.data_count = cpu_to_be16(count);
-		param.data_address = cpu_to_be32((uint32_t)t_sec);
-		param.tpc_param = 0;
+	if (!blk_rq_map_sg(msb->block_req->q, msb->block_req, msb->req_sg)) {
+		dbg(card, "IO: out of memory");
+		if (!__blk_end_request_cur(msb->block_req, -ENOMEM))
+			msb->block_req = NULL;
+		goto again;
+	}
 
-		msb->data_dir = rq_data_dir(msb->block_req);
-		msb->transfer_cmd = msb->data_dir == READ
-				    ? MSPRO_CMD_READ_DATA
-				    : MSPRO_CMD_WRITE_DATA;
+	is_read = rq_data_dir(msb->block_req) == READ;
 
-		dev_dbg(&card->dev, "data transfer: cmd %x, "
-			"lba %x, count %x\n", msb->transfer_cmd,
-			be32_to_cpu(param.data_address), count);
+	msb->current_sg_offset = 0;
+	msb->current_sg = msb->req_sg;
+	msb->data_transferred = 0;
+	msb->io_error = 0;
 
-		card->next_request = h_mspro_block_req_init;
-		msb->mrq_handler = h_mspro_block_transfer_data;
-		memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
-				  &param, sizeof(param));
-		memstick_new_req(card->host);
-		return 0;
-	}
+	msb->transfer_cmd = is_read ?
+				MSPRO_CMD_READ_DATA :MSPRO_CMD_WRITE_DATA;
 
-	dev_dbg(&card->dev, "blk_fetch\n");
-	msb->block_req = blk_fetch_request(msb->queue);
-	if (!msb->block_req) {
-		dev_dbg(&card->dev, "issue end\n");
-		return -EAGAIN;
-	}
+	msb->arg.system = msb->system;
+	msb->arg.data_count = cpu_to_be16(pages);
+	msb->arg.data_address = cpu_to_be32(sec);
+	msb->data_dir = rq_data_dir(msb->block_req);
 
-	dev_dbg(&card->dev, "trying again\n");
-	chunk = 1;
-	goto try_again;
+	dbg(card, "IO: %s: lba %x, pages %x", is_read ? "read" : "write",
+					(unsigned int)sec, pages);
+	if (first)
+		memstick_run_state_machine(card,
+			h_mspro_block_transfer_data, false);
+	return 0;
 }
 
 /*
@@ -584,59 +628,23 @@ try_again:
  *  After execution of this function, the msb->block_req might or might not
  *  be NULL. If it is, it means we don't have any more requests to process
  */
-static int mspro_block_complete_req(struct memstick_dev *card, int error)
+static void mspro_block_complete_req(struct memstick_dev *card, int error)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
-	int chunk, cnt;
-	unsigned int t_len = 0;
-	unsigned long flags;
 
-	spin_lock_irqsave(&msb->q_lock, flags);
-	dev_dbg(&card->dev, "complete %d, %d\n", msb->has_request ? 1 : 0,
-		error);
-
-	if (msb->has_request) {
-		/* Nothing to do - not really an error */
-		if (error == -EAGAIN)
-			error = 0;
-
-		if (error || (card->current_mrq.tpc == MSPRO_CMD_STOP)) {
-			if (msb->data_dir == READ) {
-				for (cnt = 0; cnt < msb->current_seg; cnt++)
-					t_len += msb->req_sg[cnt].length
-						 / msb->page_size;
-
-					if (msb->current_page)
-						t_len += msb->current_page - 1;
-
-					t_len *= msb->page_size;
-			}
-		} else
-			t_len = blk_rq_bytes(msb->block_req);
-
-		dev_dbg(&card->dev, "transferred %x (%d)\n", t_len, error);
+	dbg(card, "IO: transferred %d bytes ", msb->data_transferred);
 
-		if (error && !t_len)
-			t_len = blk_rq_cur_bytes(msb->block_req);
-
-		chunk = __blk_end_request(msb->block_req, error, t_len);
-
-		error = mspro_block_issue_req(card, chunk);
-
-		if (!error)
-			goto out;
-		else
-			msb->has_request = 0;
-	} else {
-		if (!error)
-			error = -EAGAIN;
+	if (msb->data_transferred) {
+		if (!__blk_end_request(msb->block_req, 0,
+						msb->data_transferred))
+			msb->block_req = NULL;
 	}
 
-	card->next_request = h_mspro_block_default_bad;
-	complete_all(&card->mrq_complete);
-out:
-	spin_unlock_irqrestore(&msb->q_lock, flags);
-	return error;
+	if (error && msb->block_req) {
+		dbg(card, "IO: failure (%d) of transfter of one sector", error);
+		if (!__blk_end_request(msb->block_req, 0, msb->page_size))
+			msb->block_req = NULL;
+	}
 }
 
 /*
@@ -651,7 +659,7 @@ static void mspro_block_stop(struct memstick_dev *card)
 
 	while (1) {
 		spin_lock_irqsave(&msb->q_lock, flags);
-		if (!msb->has_request) {
+		if (!msb->block_req) {
 			blk_stop_queue(msb->queue);
 			rc = 1;
 		}
@@ -692,21 +700,18 @@ static void mspro_block_submit_req(struct request_queue *q)
 {
 	struct memstick_dev *card = q->queuedata;
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
-	struct request *req = NULL;
-
-	if (msb->has_request)
-		return;
-
-	if (msb->eject) {
-		while ((req = blk_fetch_request(q)) != NULL)
-			__blk_end_request_all(req, -ENODEV);
+	int error;
 
+	if (msb->block_req) {
+		dbg_v(card,
+			"IO: block layer submits request, while we have one");
 		return;
 	}
 
-	msb->has_request = 1;
-	if (mspro_block_issue_req(card, 0))
-		msb->has_request = 0;
+	dbg(card, "IO: block layer wakes us up for request processing");
+
+	error = mspro_block_issue_req(card, true);
+	WARN_ON(error && msb->block_req != NULL);
 }
 
 /*** Initialization ***/
@@ -820,6 +825,29 @@ try_again:
 	return rc;
 }
 
+/* Read data from attribute space */
+static int mspro_block_read_attribute(struct memstick_dev *card,
+					int offset, void *buffer, int len)
+{
+	struct mspro_block_data *msb = memstick_get_drvdata(card);
+
+	dbg(card, "reading attribute space at offset %08x, size %d",
+								offset, len);
+	sg_init_one(&msb->req_sg[0], buffer, len);
+	msb->current_sg_offset = 0;
+	msb->current_sg = msb->req_sg;
+	msb->data_transferred = 0;
+	msb->io_error = 0;
+	msb->transfer_cmd = MSPRO_CMD_READ_ATRB;
+	msb->arg.system = msb->system;
+	msb->arg.data_count = cpu_to_be16(len / msb->page_size);
+	msb->arg.data_address = cpu_to_be32(offset / msb->page_size);
+	msb->data_dir = READ;
+
+	return memstick_run_state_machine(card,
+					h_mspro_block_transfer_data, true);
+}
+
 /* Memory allocated for attributes by this function should be freed by
  * mspro_block_data_clear, no matter if the initialization process succeded
  * or failed.
@@ -827,85 +855,71 @@ try_again:
 static int mspro_block_read_attributes(struct memstick_dev *card)
 {
 	struct mspro_block_data *msb = memstick_get_drvdata(card);
-	struct mspro_param_register param = {
-		.system = msb->system,
-		.data_count = cpu_to_be16(1),
-		.data_address = 0,
-		.tpc_param = 0
-	};
 	struct mspro_attribute *attr = NULL;
 	struct mspro_sys_attr *s_attr = NULL;
+
 	unsigned char *buffer = NULL;
-	int cnt, rc, attr_count;
-	unsigned int addr;
-	unsigned short page_count;
+	unsigned int buffer_size, new_buffer_size, buffer_address = 0;
+	unsigned int attr_size, attr_addr, attr_page_offset;
 
-	attr = kmalloc(msb->page_size, GFP_KERNEL);
-	if (!attr)
+	int cnt, error, attr_count;
+
+	/* Allocate initial buffer */
+	buffer_size = msb->page_size;
+	buffer_address = 0;
+	buffer = kmalloc(buffer_size, GFP_KERNEL);
+	if (!buffer)
 		return -ENOMEM;
 
-	sg_init_one(&msb->req_sg[0], attr, msb->page_size);
-	msb->seg_count = 1;
-	msb->current_seg = 0;
-	msb->current_page = 0;
-	msb->data_dir = READ;
-	msb->transfer_cmd = MSPRO_CMD_READ_ATRB;
+	/* Read the attribute list */
+	error = mspro_block_read_attribute(card, 0, buffer, buffer_size);
+	if (error)
+		goto out_free_buffer;
+
+	attr = kmalloc(buffer_size, GFP_KERNEL);
+	if (!attr)
+		goto out_free_buffer;
+	memcpy(attr, buffer, buffer_size);
 
-	card->next_request = h_mspro_block_req_init;
-	msb->mrq_handler = h_mspro_block_transfer_data;
-	memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG, &param,
-			  sizeof(param));
-	memstick_new_req(card->host);
-	wait_for_completion(&card->mrq_complete);
-	if (card->current_mrq.error) {
-		rc = card->current_mrq.error;
-		goto out_free_attr;
-	}
 
+	/* Test it for sanity */
 	if (be16_to_cpu(attr->signature) != MSPRO_BLOCK_SIGNATURE) {
 		printk(KERN_ERR "%s: unrecognized device signature %x\n",
 		       dev_name(&card->dev), be16_to_cpu(attr->signature));
-		rc = -ENODEV;
-		goto out_free_attr;
+		error = -ENODEV;
+		goto out_free_buffer;
 	}
 
-	if (attr->count > MSPRO_BLOCK_MAX_ATTRIBUTES) {
+	if (attr->count > MSPRO_BLOCK_MAX_ATTRIBUTES)
 		printk(KERN_WARNING "%s: way too many attribute entries\n",
 		       dev_name(&card->dev));
-		attr_count = MSPRO_BLOCK_MAX_ATTRIBUTES;
-	} else
-		attr_count = attr->count;
-
-	msb->attr_group.attrs = kzalloc((attr_count + 1)
-					* sizeof(struct attribute),
-					GFP_KERNEL);
-	if (!msb->attr_group.attrs) {
-		rc = -ENOMEM;
-		goto out_free_attr;
-	}
-	msb->attr_group.name = "media_attributes";
 
-	buffer = kmalloc(msb->page_size, GFP_KERNEL);
-	if (!buffer) {
-		rc = -ENOMEM;
-		goto out_free_attr;
-	}
-	memcpy(buffer, (char *)attr, msb->page_size);
-	page_count = 1;
+	attr_count = min((int)attr->count, (int)MSPRO_BLOCK_MAX_ATTRIBUTES);
+
+	/* Allocate attribute group */
+	error = -ENOMEM;
+	msb->attr_group.attrs = kzalloc((attr_count + 1) *
+					sizeof(struct attribute), GFP_KERNEL);
+	if (!msb->attr_group.attrs)
+		goto out_free_buffer;
 
+	msb->attr_group.name = "media_attributes";
+
+	/* Read all other attributes */
 	for (cnt = 0; cnt < attr_count; ++cnt) {
+
+		/* Create new sysfs attribute */
 		s_attr = kzalloc(sizeof(struct mspro_sys_attr), GFP_KERNEL);
-		if (!s_attr) {
-			rc = -ENOMEM;
+		error = -ENOMEM;
+		if (!s_attr)
 			goto out_free_buffer;
-		}
 
-		msb->attr_group.attrs[cnt] = &s_attr->dev_attr.attr;
-		addr = be32_to_cpu(attr->entries[cnt].address);
-		rc = be32_to_cpu(attr->entries[cnt].size);
-		dev_dbg(&card->dev, "adding attribute %d: id %x, address %x, "
-			"size %x\n", cnt, attr->entries[cnt].id, addr, rc);
+		sysfs_attr_init(&s_attr->dev_attr.attr);
+		s_attr->dev_attr.attr.name = s_attr->name;
+		s_attr->dev_attr.attr.mode = S_IRUGO;
 		s_attr->id = attr->entries[cnt].id;
+		s_attr->dev_attr.show = mspro_block_attr_show(s_attr->id);
+
 		if (mspro_block_attr_name(s_attr->id))
 			snprintf(s_attr->name, sizeof(s_attr->name), "%s",
 				 mspro_block_attr_name(attr->entries[cnt].id));
@@ -913,78 +927,62 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
 			snprintf(s_attr->name, sizeof(s_attr->name),
 				 "attr_x%02x", attr->entries[cnt].id);
 
-		sysfs_attr_init(&s_attr->dev_attr.attr);
-		s_attr->dev_attr.attr.name = s_attr->name;
-		s_attr->dev_attr.attr.mode = S_IRUGO;
-		s_attr->dev_attr.show = mspro_block_attr_show(s_attr->id);
+		msb->attr_group.attrs[cnt] = &s_attr->dev_attr.attr;
 
-		if (!rc)
+
+		attr_addr = be32_to_cpu(attr->entries[cnt].address);
+		attr_size = be32_to_cpu(attr->entries[cnt].size);
+		attr_page_offset = attr_addr % msb->page_size;
+
+		if (!attr_size)
 			continue;
 
-		s_attr->size = rc;
-		s_attr->data = kmalloc(rc, GFP_KERNEL);
+		dbg(card, "adding attribute %d: id %x, address %x, size %x",
+			cnt, s_attr->id, attr_addr, attr_size);
+
+		s_attr->size = attr_size;
+		s_attr->data = kmalloc(attr_size, GFP_KERNEL);
 		if (!s_attr->data) {
-			rc = -ENOMEM;
+			error = -ENOMEM;
 			goto out_free_buffer;
 		}
 
-		if (((addr / msb->page_size)
-		     == be32_to_cpu(param.data_address))
-		    && (((addr + rc - 1) / msb->page_size)
-			== be32_to_cpu(param.data_address))) {
-			memcpy(s_attr->data, buffer + addr % msb->page_size,
-			       rc);
+		/* If we already read that attribute as part of last one,
+								use that */
+		if (round_down(attr_addr, msb->page_size) == buffer_address &&
+		    attr_addr + attr_size <= buffer_address + buffer_size) {
+
+			memcpy(s_attr->data, buffer + attr_page_offset,
+								attr_size);
 			continue;
 		}
 
-		if (page_count <= (rc / msb->page_size)) {
+		/* Reallocate buffer if nessesary */
+		new_buffer_size = roundup(attr_page_offset + attr_size,
+								msb->page_size);
+		buffer_address = round_down(attr_addr, msb->page_size);
+
+		if (new_buffer_size > buffer_size) {
 			kfree(buffer);
-			page_count = (rc / msb->page_size) + 1;
-			buffer = kmalloc(page_count * msb->page_size,
-					 GFP_KERNEL);
-			if (!buffer) {
-				rc = -ENOMEM;
-				goto out_free_attr;
-			}
-		}
+			buffer_size = new_buffer_size;
+			buffer = kmalloc(buffer_size, GFP_KERNEL);
+			if (!buffer)
+				goto out_free_buffer;
 
-		param.system = msb->system;
-		param.data_count = cpu_to_be16((rc / msb->page_size) + 1);
-		param.data_address = cpu_to_be32(addr / msb->page_size);
-		param.tpc_param = 0;
-
-		sg_init_one(&msb->req_sg[0], buffer,
-			    be16_to_cpu(param.data_count) * msb->page_size);
-		msb->seg_count = 1;
-		msb->current_seg = 0;
-		msb->current_page = 0;
-		msb->data_dir = READ;
-		msb->transfer_cmd = MSPRO_CMD_READ_ATRB;
-
-		dev_dbg(&card->dev, "reading attribute pages %x, %x\n",
-			be32_to_cpu(param.data_address),
-			be16_to_cpu(param.data_count));
-
-		card->next_request = h_mspro_block_req_init;
-		msb->mrq_handler = h_mspro_block_transfer_data;
-		memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
-				  (char *)&param, sizeof(param));
-		memstick_new_req(card->host);
-		wait_for_completion(&card->mrq_complete);
-		if (card->current_mrq.error) {
-			rc = card->current_mrq.error;
-			goto out_free_buffer;
 		}
 
-		memcpy(s_attr->data, buffer + addr % msb->page_size, rc);
+		/* Finaly read and save the attrubute */
+		error = mspro_block_read_attribute(card,
+			buffer_address,
+			buffer, new_buffer_size);
+		memcpy(s_attr->data, buffer + attr_page_offset, attr_size);
 	}
 
-	rc = 0;
+	error = 0;
 out_free_buffer:
 	kfree(buffer);
-out_free_attr:
 	kfree(attr);
-	return rc;
+	return error;
 }
 
 static int mspro_block_init_card(struct memstick_dev *card)
drivers/memstick/core/mspro_block.h +35 -32

76 lines not on this page · raw message

Signature · 1 line
1.7.1
maintainer
#26 lore raw

Re: [PATCH 09/29] memstick: rework state machines + attribute read function

Quoted 7 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 09/29] memstick: rework state machines + attribute read function
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Code is rewritten to use new style of
state machines.

As I said before:
1. Rationale for this "new style".
2. Human readable names for states and state transitions.
3. Coding style.

Quoted 3 lines

Attribute read function is cleaned up and commented sparsely.

Belongs to separate patch. Attribute read function is quite isolated from everything else.

author maintainer
#27 lore raw

Re: [PATCH 09/29] memstick: rework state machines + attribute read function

Quoted 10 lines · Alex Dubov
Quoted 7 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 09/29] memstick: rework state machines + attribute read function
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Code is rewritten to use new style of
state machines.

Quoted 2 lines

As I said before:
1. Rationale for this "new style".

OK, will explain in patch description better.

Quoted 1 line

2. Human readable names for states and state transitions.

Don't want to do, I explained why.

Quoted 1 line

3. Coding style.

passed checkpatch.pl

Quoted 8 lines
Quoted 5 lines

Attribute read function is cleaned up and commented sparsely.

Belongs to separate patch. Attribute read function is quite isolated from everything else.

Its not.
Your old attribute read function plays games with param register, so I will need to change it first to use global param register, and then port it. I hate doing that. If you insist, ok.

Signature · 2 lines
Best regards,
        Maxim Levitsky
author maintainer
#28 lore raw

PATCH 10/29 memstick: mspro: create _setup_io helper.

In reply to Maxim Levitsky

This function contains common parts of IO setup
for the state machine, thus reduces the risk
of using the state machine in wrong way.

---
 drivers/memstick/core/mspro_block.c |   46 ++++++++++++++++++----------------
 1 files changed, 24 insertions(+), 22 deletions(-)
drivers/memstick/core/mspro_block.c +24 -22
index cf98fa8..0d8b30b 100644
@@ -561,6 +561,26 @@ again:
 
 /*** Data transfer ***/
 
+/* Common helper that prepares state for IO (read, write, read attributes) */
+static int mspro_block_setup_io(struct memstick_dev *card, int direction,
+				int sector, int pages, unsigned char command)
+{
+	struct mspro_block_data *msb = memstick_get_drvdata(card);
+
+	msb->current_sg_offset = 0;
+	msb->current_sg = msb->req_sg;
+	msb->data_transferred = 0;
+	msb->io_error = 0;
+
+	msb->transfer_cmd = command;
+
+	msb->arg.system = msb->system;
+	msb->arg.data_count = cpu_to_be16(pages);
+	msb->arg.data_address = cpu_to_be32(sector);
+	msb->data_dir = direction;
+	return 0;
+}
+
 /*
  * Start execution of next block request,
  * or continue execution of the current one
@@ -602,18 +622,8 @@ again:
 
 	is_read = rq_data_dir(msb->block_req) == READ;
 
-	msb->current_sg_offset = 0;
-	msb->current_sg = msb->req_sg;
-	msb->data_transferred = 0;
-	msb->io_error = 0;
-
-	msb->transfer_cmd = is_read ?
-				MSPRO_CMD_READ_DATA :MSPRO_CMD_WRITE_DATA;
-
-	msb->arg.system = msb->system;
-	msb->arg.data_count = cpu_to_be16(pages);
-	msb->arg.data_address = cpu_to_be32(sec);
-	msb->data_dir = rq_data_dir(msb->block_req);
+	mspro_block_setup_io(card, rq_data_dir(msb->block_req), sec, pages,
+		is_read ? MSPRO_CMD_READ_DATA : MSPRO_CMD_WRITE_DATA);
 
 	dbg(card, "IO: %s: lba %x, pages %x", is_read ? "read" : "write",
 					(unsigned int)sec, pages);
@@ -834,16 +844,8 @@ static int mspro_block_read_attribute(struct memstick_dev *card,
 	dbg(card, "reading attribute space at offset %08x, size %d",
 								offset, len);
 	sg_init_one(&msb->req_sg[0], buffer, len);
-	msb->current_sg_offset = 0;
-	msb->current_sg = msb->req_sg;
-	msb->data_transferred = 0;
-	msb->io_error = 0;
-	msb->transfer_cmd = MSPRO_CMD_READ_ATRB;
-	msb->arg.system = msb->system;
-	msb->arg.data_count = cpu_to_be16(len / msb->page_size);
-	msb->arg.data_address = cpu_to_be32(offset / msb->page_size);
-	msb->data_dir = READ;
-
+	mspro_block_setup_io(card, READ, offset / msb->page_size,
+				len / msb->page_size, MSPRO_CMD_READ_ATRB);
 	return memstick_run_state_machine(card,
 					h_mspro_block_transfer_data, true);
 }
Signature · 1 line
1.7.1
maintainer
#29 lore raw

Re: [PATCH 10/29] memstick: mspro: create _setup_io helper.

Quoted 10 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 10/29] memstick: mspro: create _setup_io helper.
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This function contains common parts
of IO setup
for the state machine, thus reduces the risk
of using the state machine in wrong way.

1. This should precede the read_attribute function patch.
2. Coding style.

author maintainer
#30 lore raw

Re: [PATCH 10/29] memstick: mspro: create _setup_io helper.

Quoted 14 lines · Alex Dubov
Quoted 10 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 10/29] memstick: mspro: create _setup_io helper.
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This function contains common parts
of IO setup
for the state machine, thus reduces the risk
of using the state machine in wrong way.

Quoted 1 line

1. This should precede the read_attribute function patch.

Why?

Quoted 1 line

2. Coding style.

checkpatch.pl passed.

Signature · 2 lines
Best regards,
        Maxim Levitsky
author maintainer
#31 lore raw

PATCH 11/29 memstick: mspro: use MS_TPC_EX_SET_CMD

In reply to Maxim Levitsky

This little optimization done by Sony for
PRO variant of the cards allows to bundle the param register with the command and therefore send one TPC less.

This increases IO throughput somewhat.
(4.4 -> 4.8 MB/s on Jmicron for example)

---
 drivers/memstick/core/mspro_block.c |   35 +++++++++++++----------------------
 drivers/memstick/core/mspro_block.h |    3 +--
 2 files changed, 14 insertions(+), 24 deletions(-)
drivers/memstick/core/mspro_block.c +13 -22
index 0d8b30b..e54d467 100644
@@ -438,35 +438,28 @@ static int h_mspro_block_transfer_data(struct memstick_dev *card,
 
 		if (!msb->io_error) {
 			msb->io_error = (*mrq)->error;
-			card->state = 6;
+			card->state = 5;
 		}
 	}
 again:
 	switch (card->state) {
 
 	case 0: /* send read/write command + args */
-		if (!memstick_write_regs(card,
-			offsetof(struct mspro_register, param),
-			sizeof(struct mspro_param_register),
-			(unsigned char *)&msb->arg, *mrq))
-			return 0;
-		break;
-	case 1:
-		memstick_init_req(*mrq, MS_TPC_SET_CMD,
-					&msb->transfer_cmd, 1);
+		memstick_init_req(*mrq, MS_TPC_EX_SET_CMD,
+					&msb->arg, sizeof(msb->arg));
 		break;
 
-	case 2: /* read the INT register */
+	case 1: /* read the INT register */
 		if (memstick_read_int_reg(card, *mrq, -1))
 			break;
 		card->state++;
 
-	case 3: /* process the int register */
+	case 2: /* process the int register */
 		intreg = (*mrq)->data[0];
 
 		if (intreg & (MEMSTICK_INT_CMDNAK | MEMSTICK_INT_ERR)) {
 			dbg(card, "IO: card I/O error");
-			card->state = 6;
+			card->state = 5;
 			msb->io_error = -EIO;
 			goto again;
 		}
@@ -479,7 +472,7 @@ again:
 			}
 
 			memstick_read_int_reg_cleanup(card);
-			card->state = 7;
+			card->state = 6;
 			goto again;
 		}
 
@@ -492,7 +485,7 @@ again:
 		memstick_read_int_reg_cleanup(card);
 		card->state++;
 
-	case 4: /* init transfer of the data */
+	case 3: /* init transfer of the data */
 		t_offset = msb->current_sg->offset + msb->current_sg_offset;
 
 		sg_init_table(&t_sg, 1);
@@ -505,7 +498,7 @@ again:
 		(*mrq)->need_card_int = 1;
 		break;
 
-	case 5: /* switch to next page */
+	case 4: /* switch to next page */
 		msb->current_sg_offset += msb->page_size;
 		msb->data_transferred += msb->page_size;
 
@@ -514,15 +507,15 @@ again:
 			msb->current_sg = sg_next(msb->current_sg);
 		}
 
-		card->state = 2;
+		card->state = 1;
 		goto again;
 
-	case 6: /* after a error send STOP command */
+	case 5: /* after a error send STOP command */
 		command = MSPRO_CMD_STOP;
 		memstick_init_req(*mrq, MS_TPC_SET_CMD, &command, 1);
 		break;
 
-	case 7: /* request complete - get next one*/
+	case 6: /* request complete - get next one*/
 		spin_lock_irqsave(&msb->q_lock, flags);
 
 		if (msb->io_error)
@@ -572,9 +565,7 @@ static int mspro_block_setup_io(struct memstick_dev *card, int direction,
 	msb->data_transferred = 0;
 	msb->io_error = 0;
 
-	msb->transfer_cmd = command;
-
-	msb->arg.system = msb->system;
+	msb->arg.command = command;
 	msb->arg.data_count = cpu_to_be16(pages);
 	msb->arg.data_address = cpu_to_be32(sector);
 	msb->data_dir = direction;
drivers/memstick/core/mspro_block.h +1 -2
index ba9f78c..82ae2fe 100644
@@ -151,8 +151,7 @@ struct mspro_block_data {
 
 	/* Handlers state */
 	unsigned char                    system;
-	unsigned char                    transfer_cmd;
-	struct mspro_param_register      arg;
+	struct mspro_cmdex_argument      arg;
 
 	struct scatterlist               *current_sg;
 	unsigned int                     current_sg_offset;
Signature · 1 line
1.7.1
maintainer
#32 lore raw

Re: [PATCH 11/29] memstick: mspro: use MS_TPC_EX_SET_CMD

Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 11/29] memstick: mspro: use MS_TPC_EX_SET_CMD
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This little optimization done by Sony
for
PRO variant of the cards allows to bundle the param
register
with the command and therefore send one TPC less.

Quoted 3 lines

This increases IO throughput somewhat.
(4.4 -> 4.8 MB/s on Jmicron for example)

1. Names for states.
2. Coding style.
3. Introduction of struct mspro_cmdex_argument belongs to this patch.

author maintainer
#33 lore raw

Re: [PATCH 11/29] memstick: mspro: use MS_TPC_EX_SET_CMD

Quoted 14 lines · Alex Dubov
Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 11/29] memstick: mspro: use MS_TPC_EX_SET_CMD
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This little optimization done by Sony
for
PRO variant of the cards allows to bundle the param
register
with the command and therefore send one TPC less.

Quoted 6 lines
Quoted 3 lines

This increases IO throughput somewhat.
(4.4 -> 4.8 MB/s on Jmicron for example)

1. Names for states.
2. Coding style.

Already said that many times.
It passes checkpatch.pl.

Quoted 1 line

3. Introduction of struct mspro_cmdex_argument belongs to this patch.

I won't fight over that one, but I think that its doesn't matter.

Best regards,
Maxim Levitsky

author maintainer
#34 lore raw

PATCH 12/29 memstick: mspro: rework interface switch

In reply to Maxim Levitsky

Now no old style state machine exist.
Thus this patch removes now unused code.

---
 drivers/memstick/core/memstick.c    |   15 --
 drivers/memstick/core/mspro_block.c |  328 +++++++++++++++++------------------
 drivers/memstick/core/mspro_block.h |    4 +-
 include/linux/memstick.h            |    2 -
 4 files changed, 162 insertions(+), 187 deletions(-)
drivers/memstick/core/memstick.c +0 -15
index e1aa089..5eea1b2 100644
@@ -424,21 +424,6 @@ int memstick_set_rw_addr(struct memstick_dev *card)
 EXPORT_SYMBOL(memstick_set_rw_addr);
 
 
-/**
- * memstick_new_req - notify the host that some requests are pending
- * @host - host to use
- */
-void memstick_new_req(struct memstick_host *host)
-{
-	if (host->card) {
-		host->retries = cmd_retries;
-		INIT_COMPLETION(host->card->mrq_complete);
-		host->request(host);
-	}
-}
-EXPORT_SYMBOL(memstick_new_req);
-
-
 /*** state machine support code ***/
 
 /**
drivers/memstick/core/mspro_block.c +161 -167

393 lines not on this page · raw message

drivers/memstick/core/mspro_block.h +1 -3
index 82ae2fe..a7ba42d 100644
@@ -135,9 +135,6 @@ struct mspro_block_data {
 	spinlock_t                       q_lock;
 	struct scatterlist               req_sg[MSPRO_BLOCK_MAX_SEGS];
 
-	int                           (*mrq_handler)(struct memstick_dev *card,
-						struct memstick_request **mrq);
-
 	unsigned char                    read_only:1;
 	unsigned char                    eject:1;
 	unsigned char                    active:1;
@@ -157,6 +154,7 @@ struct mspro_block_data {
 	unsigned int                     current_sg_offset;
 	unsigned int	                 data_transferred;
 	unsigned char                    data_dir:1;
+	unsigned int                     target_interface;
 	int                              io_error;
 };
 
include/linux/memstick.h +0 -2
index 73586cb..4700543 100644
@@ -366,8 +366,6 @@ int memstick_exit_state_machine(struct memstick_dev *card,
 void memstick_allocate_request(struct memstick_dev *card,
 					struct memstick_request **mrq);
 
-void memstick_new_req(struct memstick_host *host);
-
 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
 			  const struct scatterlist *sg);
 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
Signature · 1 line
1.7.1
maintainer
#35 lore raw

Re: [PATCH 12/29] memstick: mspro: rework interface switch

Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 12/29] memstick: mspro: rework interface switch
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Now no old style state machine
exist.
Thus this patch removes now unused code.

This patch does somewhat more, than just removing the dead code. Description/rationale?

author maintainer
#36 lore raw

Re: [PATCH 12/29] memstick: mspro: rework interface switch

Quoted 13 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 12/29] memstick: mspro: rework interface switch
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Now no old style state machine
exist.
Thus this patch removes now unused code.

Quoted 2 lines

This patch does somewhat more, than just removing the dead code. Description/rationale?

I will update the patch description.

Best regards,
Maxim Levitsky

author maintainer
#37 lore raw

PATCH 13/29 memstick: core: stop passing pointer to card->current_mrq

In reply to Maxim Levitsky

This cleans up a lot of code and makes the assumption (*mrq == &card->current_mrq) official.

---
 drivers/memstick/core/memstick.c    |  135 +++++++++++++++--------------------
 drivers/memstick/core/mspro_block.c |  102 ++++++++++++--------------
 include/linux/memstick.h            |   26 ++-----
 3 files changed, 114 insertions(+), 149 deletions(-)
drivers/memstick/core/memstick.c +59 -76
index 5eea1b2..9de64eb 100644
@@ -202,7 +202,6 @@ static int memstick_dummy_check(struct memstick_dev *card)
 	return 0;
 }
 
-
 /*
  * Functions prefixed with "h_" are protocol callbacks. They can be called from
  * interrupt context. Return value of 0 means that request processing is still
@@ -210,60 +209,57 @@ static int memstick_dummy_check(struct memstick_dev *card)
  * finished (and request processor should come back some time later).
  */
 
-static int h_memstick_read_dev_id(struct memstick_dev *card,
-						struct memstick_request **mrq)
+static int h_memstick_read_dev_id(struct memstick_dev *card)
 {
 	struct ms_id_register id_reg;
+	struct memstick_request *mrq = &card->current_mrq;
 
-	memstick_allocate_request(card, mrq);
-	if ((*mrq)->error)
-		return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
+	if (mrq->error)
+		return memstick_exit_state_machine(card, mrq->error);
 
 	switch (card->state) {
 	case 0:
 		if (!memstick_read_regs(card,
 			offsetof(struct ms_register, id),
-			sizeof(struct ms_id_register), *mrq))
+			sizeof(struct ms_id_register)))
 			return 0;
 		break;
 	case 1:
-		memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
+		memcpy(&id_reg, mrq->data, sizeof(id_reg));
 		card->id.match_flags = MEMSTICK_MATCH_ALL;
 		card->id.type = id_reg.type;
 		card->id.category = id_reg.category;
 		card->id.class = id_reg.class;
 		dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
-		return memstick_exit_state_machine(card, *mrq, 0);
+		return memstick_exit_state_machine(card, 0);
 	}
 
 	card->state++;
 	return 0;
 }
 
-static int h_memstick_set_rw_addr(struct memstick_dev *card,
-				  struct memstick_request **mrq)
+static int h_memstick_set_rw_addr(struct memstick_dev *card)
 {
-	memstick_allocate_request(card, mrq);
-	if ((*mrq)->error)
-		return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
+	struct memstick_request *mrq = &card->current_mrq;
+
+	if (mrq->error)
+		return memstick_exit_state_machine(card, mrq->error);
 
 	switch (card->state) {
 	case 0:
-		memstick_init_req(*mrq, MS_TPC_SET_RW_REG_ADRS,
+		memstick_init_req(card, MS_TPC_SET_RW_REG_ADRS,
 				  (char *)&card->reg_addr,
 				  sizeof(card->reg_addr));
 		break;
 	case 1:
-		return memstick_exit_state_machine(card, *mrq, 0);
+		return memstick_exit_state_machine(card, 0);
 	}
 
 	card->state++;
 	return 0;
 }
 
-
-static int h_memstick_default_bad(struct memstick_dev *card,
-				     struct memstick_request **mrq)
+static int h_memstick_default_bad(struct memstick_dev *card)
 {
 	return -ENXIO;
 }
@@ -273,7 +269,6 @@ static void memstick_invalidate_reg_window(struct memstick_dev *card)
 	memset(&card->reg_addr, 0, sizeof(card->reg_addr));
 }
 
-
 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 {
 	struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
@@ -436,8 +431,7 @@ EXPORT_SYMBOL(memstick_set_rw_addr);
  * memstick_exit_state_machine
  */
 int memstick_run_state_machine(struct memstick_dev *card,
-	int   (*state_func)(struct memstick_dev *card,
-			struct memstick_request **mrq), bool sync)
+	int   (*state_func)(struct memstick_dev *card), bool sync)
 {
 	WARN_ON(card->state != -1);
 
@@ -472,9 +466,10 @@ EXPORT_SYMBOL(memstick_run_state_machine);
  *
  * State machines call this to signal quit
  */
-int memstick_exit_state_machine(struct memstick_dev *card,
-			struct memstick_request *req, int error)
+int memstick_exit_state_machine(struct memstick_dev *card, int error)
 {
+	WARN_ON(card->state == -1);
+
 	card->state = -1;
 	card->exit_error = error;
 	card->next_request = h_memstick_default_bad;
@@ -488,24 +483,7 @@ int memstick_exit_state_machine(struct memstick_dev *card,
 }
 EXPORT_SYMBOL(memstick_exit_state_machine);
 
-/**
- * memstick_allocate_request - create new request for use in request handler
- * @card - card to use
- * @mrq - request to initialize
- */
-void memstick_allocate_request(struct memstick_dev *card,
-					struct memstick_request **mrq)
-{
-	if (*mrq == NULL) {
-		*mrq = &card->current_mrq;
-		(*mrq)->error = 0;
-		(*mrq)->need_card_int = 0;
-		card->int_polling = false;
-		card->state = 0;
-	}
-}
-EXPORT_SYMBOL(memstick_allocate_request);
-
+/*** functions to be called by state machines ***/
 
 /**
  * memstick_init_req_sg - set request fields needed for bulk data transfer
@@ -513,9 +491,12 @@ EXPORT_SYMBOL(memstick_allocate_request);
  * @tpc - memstick Transport Protocol Command
  * @sg - TPC argument
  */
-void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
+void memstick_init_req_sg(struct memstick_dev *card, unsigned char tpc,
 			  const struct scatterlist *sg)
 {
+	struct memstick_request *mrq = &card->current_mrq;
+	WARN_ON(card->state == -1);
+
 	mrq->tpc = tpc;
 	if (tpc & 8)
 		mrq->data_dir = WRITE;
@@ -529,6 +510,10 @@ void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
 		mrq->need_card_int = 1;
 	else
 		mrq->need_card_int = 0;
+
+	if (tpc != MS_TPC_GET_INT)
+		card->int_polling = false;
+
 }
 EXPORT_SYMBOL(memstick_init_req_sg);
 
@@ -543,9 +528,12 @@ EXPORT_SYMBOL(memstick_init_req_sg);
  * in size) allows us to just copy the value between request structure and
  * user supplied buffer.
  */
-void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
+void memstick_init_req(struct memstick_dev *card, unsigned char tpc,
 		       const void *buf, size_t length)
 {
+	struct memstick_request *mrq = &card->current_mrq;
+	WARN_ON(card->state == -1);
+
 	mrq->tpc = tpc;
 	if (tpc & 8)
 		mrq->data_dir = WRITE;
@@ -562,6 +550,10 @@ void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
 		mrq->need_card_int = 1;
 	else
 		mrq->need_card_int = 0;
+
+	if (tpc != MS_TPC_GET_INT)
+		card->int_polling = false;
+
 }
 EXPORT_SYMBOL(memstick_init_req);
 
@@ -575,27 +567,28 @@ EXPORT_SYMBOL(memstick_init_req);
  * @card - card to use
  * @timeout - the timeout. if -1, then uses default
  */
-int memstick_read_int_reg(struct memstick_dev *card,
-				struct memstick_request *req, long timeout)
+
+int memstick_read_int_reg(struct memstick_dev *card, long timeout)
 {
+	struct memstick_request *mrq = &card->current_mrq;
+	WARN_ON(card->state == -1);
 
 	if (!card->int_polling) {
 		card->int_timeout = jiffies +
 			msecs_to_jiffies(timeout == -1 ? 500 : timeout);
 		card->int_polling = true;
 	} else if (time_after(jiffies, card->int_timeout)) {
-		req->data[0] = MEMSTICK_INT_CMDNAK;
+		mrq->data[0] = MEMSTICK_INT_CMDNAK;
 		return 0;
 	}
 
 	if (((card->caps | card->host->caps) & MEMSTICK_CAP_AUTO_GET_INT) &&
-							req->need_card_int) {
-		BUG_ON(req->error);
-		req->data[0] = req->int_reg;
-		req->need_card_int = 0;
+				mrq->need_card_int && !mrq->error) {
+		mrq->data[0] = mrq->int_reg;
+		mrq->need_card_int = false;
 		return 0;
 	} else {
-		memstick_init_req(req, MS_TPC_GET_INT, NULL, 1);
+		memstick_init_req(card, MS_TPC_GET_INT, NULL, 1);
 		return 1;
 	}
 }
@@ -603,19 +596,6 @@ EXPORT_SYMBOL(memstick_read_int_reg);
 
 
 /**
- * memstick_read_int_reg_cleanup - cleanup after series of calls to
- * memstick_read_int_reg. Used to cancel timeout.
- * Use this if you use memstick_read_int_reg
- * @card - card to use
- */
-void memstick_read_int_reg_cleanup(struct memstick_dev *card)
-{
-	card->int_polling = false;
-}
-EXPORT_SYMBOL(memstick_read_int_reg_cleanup);
-
-
-/**
  * memstick_read_regs - read the ms registers
  * If there is need to change the R/W window,
  * it will create the MS_TPC_SET_RW_REG_ADRS request and return 0,
@@ -626,9 +606,10 @@ EXPORT_SYMBOL(memstick_read_int_reg_cleanup);
  * @req - request to use
  */
 
-int memstick_read_regs(struct memstick_dev *card, int offset, int len,
-	struct memstick_request *req)
+int memstick_read_regs(struct memstick_dev *card, int offset, int len)
 {
+	WARN_ON(card->state == -1);
+
 	if (card->reg_addr.r_offset != offset ||
 					card->reg_addr.r_length != len) {
 		card->reg_addr.r_offset = offset;
@@ -642,12 +623,12 @@ int memstick_read_regs(struct memstick_dev *card, int offset, int len,
 			card->reg_addr.w_length = sizeof(struct ms_id_register);
 		}
 
-		memstick_init_req(req, MS_TPC_SET_RW_REG_ADRS, &card->reg_addr,
+		memstick_init_req(card, MS_TPC_SET_RW_REG_ADRS, &card->reg_addr,
 			sizeof(card->reg_addr));
 		return 0;
 	}
 
-	memstick_init_req(req, MS_TPC_READ_REG, NULL, len);
+	memstick_init_req(card, MS_TPC_READ_REG, NULL, len);
 	return 1;
 }
 EXPORT_SYMBOL(memstick_read_regs);
@@ -664,8 +645,10 @@ EXPORT_SYMBOL(memstick_read_regs);
  * @req - request to use
  */
 int memstick_write_regs(struct memstick_dev *card, int offset, int len,
-	char *buf, struct memstick_request *req)
+	char *buf)
 {
+	WARN_ON(card->state == -1);
+
 	if (card->reg_addr.w_offset != offset ||
 					card->reg_addr.w_length != len) {
 		card->reg_addr.w_offset = offset;
@@ -676,16 +659,15 @@ int memstick_write_regs(struct memstick_dev *card, int offset, int len,
 		if (!card->reg_addr.r_length) {
 			card->reg_addr.r_offset =
 					offsetof(struct ms_register, id);
-
 			card->reg_addr.r_length = sizeof(struct ms_id_register);
 		}
 
-		memstick_init_req(req, MS_TPC_SET_RW_REG_ADRS, &card->reg_addr,
+		memstick_init_req(card, MS_TPC_SET_RW_REG_ADRS, &card->reg_addr,
 			sizeof(card->reg_addr));
 		return 0;
 	}
 
-	memstick_init_req(req, MS_TPC_WRITE_REG, buf, len);
+	memstick_init_req(card, MS_TPC_WRITE_REG, buf, len);
 	return 1;
 }
 EXPORT_SYMBOL(memstick_write_regs);
@@ -885,11 +867,12 @@ int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
 	}
 
 	if (host->card && host->card->next_request)
-		rc = host->card->next_request(host->card, mrq);
+		rc = host->card->next_request(host->card);
 
-	if (!rc)
+	if (!rc) {
+		*mrq = &host->card->current_mrq;
 		host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
-	else
+	} else
 		*mrq = NULL;
 
 	return rc;
drivers/memstick/core/mspro_block.c +47 -55

259 lines not on this page · raw message

include/linux/memstick.h +8 -18
index 4700543..5fd4beb 100644
@@ -288,8 +288,7 @@ struct memstick_dev {
 	/* Check that media driver is still willing to operate the device. */
 	int                      (*check)(struct memstick_dev *card);
 	/* Get next request from the media driver.                         */
-	int                      (*next_request)(struct memstick_dev *card,
-						 struct memstick_request **mrq);
+	int                      (*next_request)(struct memstick_dev *card);
 	/* Tell the media driver to stop doing things                      */
 	void                     (*stop)(struct memstick_dev *card);
 	/* Allow the media driver to continue                              */
@@ -357,30 +356,21 @@ void memstick_unregister_driver(struct memstick_driver *drv);
 int memstick_set_rw_addr(struct memstick_dev *card);
 
 int memstick_run_state_machine(struct memstick_dev *card,
-	int   (*state_func)(struct memstick_dev *card,
-			struct memstick_request **mrq), bool sync);
+	int   (*state_func)(struct memstick_dev *card), bool sync);
 
-int memstick_exit_state_machine(struct memstick_dev *card,
-			struct memstick_request *req, int error);
+int memstick_exit_state_machine(struct memstick_dev *card, int error);
 
-void memstick_allocate_request(struct memstick_dev *card,
-					struct memstick_request **mrq);
-
-void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
+void memstick_init_req_sg(struct memstick_dev *card, unsigned char tpc,
 			  const struct scatterlist *sg);
-void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
+void memstick_init_req(struct memstick_dev *card, unsigned char tpc,
 		       const void *buf, size_t length);
 
-int memstick_read_int_reg(struct memstick_dev *card,
-				struct memstick_request *req, long timeout);
-
-void memstick_read_int_reg_cleanup(struct memstick_dev *card);
+int memstick_read_int_reg(struct memstick_dev *card, long timeout);
 
-int memstick_read_regs(struct memstick_dev *card, int offset, int len,
-	struct memstick_request *req);
+int memstick_read_regs(struct memstick_dev *card, int offset, int len);
 
 int memstick_write_regs(struct memstick_dev *card, int offset, int len,
-	char *buf, struct memstick_request *req);
+	char *buf);
 
 const char *memstick_debug_get_tpc_name(int tpc);
 
Signature · 1 line
1.7.1
maintainer
#38 lore raw

Re: [PATCH 13/29] memstick: core: stop passing pointer to card->current_mrq

Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 13/29] memstick: core: stop passing pointer to card->current_mrq
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This cleans up a lot of code and
makes the assumption
(*mrq == &card->current_mrq) official.

---

Unfortunately, the description does not match the patch.
While the main optimization (merging req and card arguments for good) is fully reasonable given the posterior knowledge of MSPro evolution, this patch introduces some functional changes as well, which can not be considered to be a pure cleanup. Some WARN_ONs also appear to be misplaced:

Quoted 8 lines
        if (msb->block_req) {
drivers/memstick/core/mspro_block.c +3 -2
-            mspro_block_complete_req(card, (*mrq)->error);
+            mspro_block_complete_req(card, mrq->error);
            error = mspro_block_issue_req(card, false);
 
-            if (!msb->block_req) {
+            if (error) {
+                WARN_ON(msb->block_req);
author maintainer
#39 lore raw

Re: [PATCH 13/29] memstick: core: stop passing pointer to card->current_mrq

Quoted 12 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 13/29] memstick: core: stop passing pointer to card->current_mrq
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This cleans up a lot of code and
makes the assumption
(*mrq == &card->current_mrq) official.

Quoted 8 lines
Quoted 2 lines

---

Unfortunately, the description does not match the patch. While the main optimization (merging req and card arguments for good) is fully reasonable given the posterior knowledge of MSPro evolution, this patch introduces some functional changes as well, which can not be considered to be a pure cleanup.

Agreed, some stuff slipped to that patch, will split.

Quoted 10 lines

Some WARN_ONs also appear to be misplaced:

Quoted 8 lines
        if (msb->block_req) {
drivers/memstick/core/mspro_block.c +3 -2
-            mspro_block_complete_req(card, (*mrq)->error);
+            mspro_block_complete_req(card, mrq->error);
            error = mspro_block_issue_req(card, false);
 
-            if (!msb->block_req) {
+            if (error) {
+                WARN_ON(msb->block_req);

Nope that on purpose.
If mspro_block_issue_req returns error, the msb->block_req must be NULL.

Best regards,
Maxim Levitsky

author maintainer
#40 lore raw

PATCH 14/29 memstick: remove the memstick_set_rw_addr

In reply to Maxim Levitsky

Remove this function, what was
last user that did send the MS_TPC_SET_RW_REG_ADRS directly.

Just invalidate the register window, and next register read/write will send that tpc automaticly.

---
 drivers/memstick/core/memstick.c |   49 ++++----------------------------------
 1 files changed, 5 insertions(+), 44 deletions(-)
drivers/memstick/core/memstick.c +5 -44
index 9de64eb..66fc9d6 100644
@@ -238,27 +238,6 @@ static int h_memstick_read_dev_id(struct memstick_dev *card)
 	return 0;
 }
 
-static int h_memstick_set_rw_addr(struct memstick_dev *card)
-{
-	struct memstick_request *mrq = &card->current_mrq;
-
-	if (mrq->error)
-		return memstick_exit_state_machine(card, mrq->error);
-
-	switch (card->state) {
-	case 0:
-		memstick_init_req(card, MS_TPC_SET_RW_REG_ADRS,
-				  (char *)&card->reg_addr,
-				  sizeof(card->reg_addr));
-		break;
-	case 1:
-		return memstick_exit_state_machine(card, 0);
-	}
-
-	card->state++;
-	return 0;
-}
-
 static int h_memstick_default_bad(struct memstick_dev *card)
 {
 	return -ENXIO;
@@ -274,7 +253,6 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 	struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
 					    GFP_KERNEL);
 	struct memstick_dev *old_card = host->card;
-	struct ms_id_register id_reg;
 
 	if (card) {
 		card->host = host;
@@ -284,18 +262,12 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 		card->dev.release = memstick_free_card;
 		card->check = memstick_dummy_check;
 
-		card->reg_addr.r_offset = offsetof(struct ms_register, id);
-		card->reg_addr.r_length = sizeof(id_reg);
-		card->reg_addr.w_offset = offsetof(struct ms_register, id);
-		card->reg_addr.w_length = sizeof(id_reg);
-
 		host->card = card;
 		init_completion(&card->mrq_complete);
 		card->state = -1;
 		card->next_request = h_memstick_default_bad;
 
-		if (memstick_set_rw_addr(card))
-			goto err_out;
+		memstick_invalidate_reg_window(card);
 
 		if (memstick_run_state_machine(card,
 						h_memstick_read_dev_id, true))
@@ -340,8 +312,10 @@ static void memstick_check(struct work_struct *work)
 	if (!host->card) {
 		if (memstick_power_on(host))
 			goto out_power_off;
-	} else if (host->card->stop)
+	} else if (host->card->stop) {
 		host->card->stop(host->card);
+		memstick_invalidate_reg_window(host->card);
+	}
 
 	card = memstick_alloc_card(host);
 
@@ -354,8 +328,7 @@ static void memstick_check(struct work_struct *work)
 		dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
 			card->id.type, card->id.category, card->id.class);
 		if (host->card) {
-			if (memstick_set_rw_addr(host->card)
-			    || !memstick_dev_match(host->card, &card->id)
+			if (!memstick_dev_match(host->card, &card->id)
 			    || !(host->card->check(host->card))) {
 				device_unregister(&host->card->dev);
 				host->card = NULL;
@@ -407,18 +380,6 @@ void memstick_unregister_driver(struct memstick_driver *drv)
 EXPORT_SYMBOL(memstick_unregister_driver);
 
 
-/**
- * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
- *                        complete
- * @card - media device to use
- */
-int memstick_set_rw_addr(struct memstick_dev *card)
-{
-	return memstick_run_state_machine(card, h_memstick_set_rw_addr, true);
-}
-EXPORT_SYMBOL(memstick_set_rw_addr);
-
-
 /*** state machine support code ***/
 
 /**
Signature · 1 line
1.7.1
maintainer
#41 lore raw

Re: [PATCH 14/29] memstick: remove the memstick_set_rw_addr

Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 14/29] memstick: remove the memstick_set_rw_addr
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Remove this function, what was
last user that did send the MS_TPC_SET_RW_REG_ADRS
directly.

Quoted 5 lines

Just invalidate the register window, and next register read/write will send that tpc automaticly.

---

How is an obscure invalidate_reg_window function is any better than explicit set_rw_addr? Total number of calls to either of them is exactly the same.

Sony state machine diagrams suggest that doing a precise set_rw_addr when necessary is a good thing. The feature was originally conceived because Sony intended to manufacture MSIO and hybrid devices, which might have very large number of registers (hundreds). It was also supposed to help with backward compatibility of devices, as well as with DRM functionality

We know, at this point of time, that Sony is sort of loosing the format war, so MSIO devices these days are very hard to come by. However, some hybrid (Transfer Jet) and DRM-secured devices still exist and it is wise to retain functionality which can help to operate those (I don't have full details on their operation, but it doesn't mean we should forget them outright).

author maintainer
#42 lore raw

Re: [PATCH 14/29] memstick: remove the memstick_set_rw_addr

Quoted 15 lines · Alex Dubov
Quoted 12 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 14/29] memstick: remove the memstick_set_rw_addr
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Remove this function, what was
last user that did send the MS_TPC_SET_RW_REG_ADRS
directly.

Just invalidate the register window, and next register read/write will send that tpc automaticly.

Quoted 6 lines
Quoted 2 lines

---

How is an obscure invalidate_reg_window function is any better than explicit set_rw_addr? Total number of calls to either of them is exactly the same.

Nope.
I just set the reg window where it should be: in register read/write functions.
Here we tampered with register window by using another card structure, so we invalidate it. Simple.
The point is that I send the register window update just before register read/write, and optionaly skip that if cached version matches the one I need.

Quoted 3 lines

Sony state machine diagrams suggest that doing a precise set_rw_addr when necessary is a good thing.

And that exactly what I am doing.
I am setting that window just before a register read/write.

Quoted 11 lines

The feature was originally conceived because
Sony intended to manufacture MSIO and hybrid devices, which might have very large number of registers (hundreds). It was also supposed to help with backward compatibility of devices, as well as with DRM functionality

We know, at this point of time, that Sony is sort of loosing the format war, so MSIO devices these days are very hard to come by. However, some hybrid (Transfer Jet) and DRM-secured devices still exist and it is wise to retain functionality which can help to operate those (I don't have full details on their operation, but it doesn't mean we should forget them outright).

Best regards,
Maxim Levitsky

author maintainer
#43 lore raw

PATCH 15/29 memstick: jmb38x_ms: Create header

In reply to Maxim Levitsky

In the new header add:

* debug macros
* Registers + some documntation

---
 drivers/memstick/host/jmb38x_ms.c |  139 +--------------------------
 drivers/memstick/host/jmb38x_ms.h |  188 +++++++++++++++++++++++++++++++++++++
 2 files changed, 194 insertions(+), 133 deletions(-)
 create mode 100644 drivers/memstick/host/jmb38x_ms.h
drivers/memstick/host/jmb38x_ms.c +6 -133
index f2b894c..7a00bef 100644
@@ -17,141 +17,10 @@
 #include <linux/highmem.h>
 #include <linux/memstick.h>
 #include <linux/slab.h>
-
-#define DRIVER_NAME "jmb38x_ms"
+#include "jmb38x_ms.h"
 
 static int no_dma;
-module_param(no_dma, bool, 0644);
-
-enum {
-	DMA_ADDRESS       = 0x00,
-	BLOCK             = 0x04,
-	DMA_CONTROL       = 0x08,
-	TPC_P0            = 0x0c,
-	TPC_P1            = 0x10,
-	TPC               = 0x14,
-	HOST_CONTROL      = 0x18,
-	DATA              = 0x1c,
-	STATUS            = 0x20,
-	INT_STATUS        = 0x24,
-	INT_STATUS_ENABLE = 0x28,
-	INT_SIGNAL_ENABLE = 0x2c,
-	TIMER             = 0x30,
-	TIMER_CONTROL     = 0x34,
-	PAD_OUTPUT_ENABLE = 0x38,
-	PAD_PU_PD         = 0x3c,
-	CLOCK_DELAY       = 0x40,
-	ADMA_ADDRESS      = 0x44,
-	CLOCK_CONTROL     = 0x48,
-	LED_CONTROL       = 0x4c,
-	VERSION           = 0x50
-};
-
-struct jmb38x_ms_host {
-	struct jmb38x_ms        *chip;
-	void __iomem            *addr;
-	spinlock_t              lock;
-	struct tasklet_struct   notify;
-	int                     id;
-	char                    host_id[32];
-	int                     irq;
-	unsigned int            block_pos;
-	unsigned long           timeout_jiffies;
-	struct timer_list       timer;
-	struct memstick_request *req;
-	unsigned char           cmd_flags;
-	unsigned char           io_pos;
-	unsigned int            io_word[2];
-};
-
-struct jmb38x_ms {
-	struct pci_dev        *pdev;
-	int                   host_cnt;
-	struct memstick_host  *hosts[];
-};
-
-#define BLOCK_COUNT_MASK       0xffff0000
-#define BLOCK_SIZE_MASK        0x00000fff
-
-#define DMA_CONTROL_ENABLE     0x00000001
-
-#define TPC_DATA_SEL           0x00008000
-#define TPC_DIR                0x00004000
-#define TPC_WAIT_INT           0x00002000
-#define TPC_GET_INT            0x00000800
-#define TPC_CODE_SZ_MASK       0x00000700
-#define TPC_DATA_SZ_MASK       0x00000007
-
-#define HOST_CONTROL_TDELAY_EN 0x00040000
-#define HOST_CONTROL_HW_OC_P   0x00010000
-#define HOST_CONTROL_RESET_REQ 0x00008000
-#define HOST_CONTROL_REI       0x00004000
-#define HOST_CONTROL_LED       0x00000400
-#define HOST_CONTROL_FAST_CLK  0x00000200
-#define HOST_CONTROL_RESET     0x00000100
-#define HOST_CONTROL_POWER_EN  0x00000080
-#define HOST_CONTROL_CLOCK_EN  0x00000040
-#define HOST_CONTROL_REO       0x00000008
-#define HOST_CONTROL_IF_SHIFT  4
-
-#define HOST_CONTROL_IF_SERIAL 0x0
-#define HOST_CONTROL_IF_PAR4   0x1
-#define HOST_CONTROL_IF_PAR8   0x3
-
-#define STATUS_BUSY             0x00080000
-#define STATUS_MS_DAT7          0x00040000
-#define STATUS_MS_DAT6          0x00020000
-#define STATUS_MS_DAT5          0x00010000
-#define STATUS_MS_DAT4          0x00008000
-#define STATUS_MS_DAT3          0x00004000
-#define STATUS_MS_DAT2          0x00002000
-#define STATUS_MS_DAT1          0x00001000
-#define STATUS_MS_DAT0          0x00000800
-#define STATUS_HAS_MEDIA        0x00000400
-#define STATUS_FIFO_EMPTY       0x00000200
-#define STATUS_FIFO_FULL        0x00000100
-#define STATUS_MS_CED           0x00000080
-#define STATUS_MS_ERR           0x00000040
-#define STATUS_MS_BRQ           0x00000020
-#define STATUS_MS_CNK           0x00000001
-
-#define INT_STATUS_TPC_ERR      0x00080000
-#define INT_STATUS_CRC_ERR      0x00040000
-#define INT_STATUS_TIMER_TO     0x00020000
-#define INT_STATUS_HSK_TO       0x00010000
-#define INT_STATUS_ANY_ERR      0x00008000
-#define INT_STATUS_FIFO_WRDY    0x00000080
-#define INT_STATUS_FIFO_RRDY    0x00000040
-#define INT_STATUS_MEDIA_OUT    0x00000010
-#define INT_STATUS_MEDIA_IN     0x00000008
-#define INT_STATUS_DMA_BOUNDARY 0x00000004
-#define INT_STATUS_EOTRAN       0x00000002
-#define INT_STATUS_EOTPC        0x00000001
-
-#define INT_STATUS_ALL          0x000f801f
-
-#define PAD_OUTPUT_ENABLE_MS  0x0F3F
-
-#define PAD_PU_PD_OFF         0x7FFF0000
-#define PAD_PU_PD_ON_MS_SOCK0 0x5f8f0000
-#define PAD_PU_PD_ON_MS_SOCK1 0x0f0f0000
-
-#define CLOCK_CONTROL_40MHZ   0x00000001
-#define CLOCK_CONTROL_50MHZ   0x0000000a
-#define CLOCK_CONTROL_60MHZ   0x00000008
-#define CLOCK_CONTROL_62_5MHZ 0x0000000c
-#define CLOCK_CONTROL_OFF     0x00000000
-
-#define PCI_CTL_CLOCK_DLY_ADDR   0x000000b0
-#define PCI_CTL_CLOCK_DLY_MASK_A 0x00000f00
-#define PCI_CTL_CLOCK_DLY_MASK_B 0x0000f000
-
-enum {
-	CMD_READY    = 0x01,
-	FIFO_READY   = 0x02,
-	REG_DATA     = 0x04,
-	DMA_DATA     = 0x08
-};
+static int debug;
 
 static unsigned int jmb38x_ms_read_data(struct jmb38x_ms_host *host,
 					unsigned char *buf, unsigned int length)
@@ -1012,5 +881,9 @@ MODULE_DESCRIPTION("JMicron jmb38x MemoryStick driver");
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, jmb38x_ms_id_tbl);
 
+module_param(no_dma, bool, S_IRUGO);
+module_param(debug, bool, S_IRUGO);
+
+
 module_init(jmb38x_ms_init);
 module_exit(jmb38x_ms_exit);
drivers/memstick/host/jmb38x_ms.h new file +188 -0

188 lines not on this page · raw message

Signature · 1 line
1.7.1
maintainer
#44 lore raw

Re: [PATCH 15/29] memstick: jmb38x_ms: Create header

Quoted 7 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 15/29] memstick: jmb38x_ms: Create header
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
In the new header add:

Quoted 5 lines

* debug macros
* Registers + some documntation

---

Yet again, what's wrong with DYNAMIC_DEBUG?

author maintainer
#45 lore raw

Re: [PATCH 15/29] memstick: jmb38x_ms: Create header

Quoted 10 lines · Alex Dubov
Quoted 7 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 15/29] memstick: jmb38x_ms: Create header
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
In the new header add:

Quoted 7 lines
Quoted 5 lines

* debug macros
* Registers + some documntation

---

Yet again, what's wrong with DYNAMIC_DEBUG?

DYNAMIC_DEBUG:

a) has to be enabled by distro.
b) lacks debug levels.

And it is used unless user sets the debug= argument. You did read the patch didn't you?

Best regards,
Maxim Levitsky

author maintainer
#46 lore raw

PATCH 16/29 memstick: jmb38x_ms: s/jmb38x_ms/j38ms/g

In reply to Maxim Levitsky

This just makes it easier to type function names
while still keeping the meaning
Driver name and filenames are left unchanged.

---
 drivers/memstick/host/jmb38x_ms.c |  154 ++++++++++++++++++------------------
 drivers/memstick/host/jmb38x_ms.h |    6 +-
 2 files changed, 80 insertions(+), 80 deletions(-)
drivers/memstick/host/jmb38x_ms.c +77 -77
index 7a00bef..e896a4d 100644
@@ -22,7 +22,7 @@
 static int no_dma;
 static int debug;
 
-static unsigned int jmb38x_ms_read_data(struct jmb38x_ms_host *host,
+static unsigned int j38ms_read_data(struct j38ms_host *host,
 					unsigned char *buf, unsigned int length)
 {
 	unsigned int off = 0;
@@ -60,7 +60,7 @@ static unsigned int jmb38x_ms_read_data(struct jmb38x_ms_host *host,
 	return off;
 }
 
-static unsigned int jmb38x_ms_read_reg_data(struct jmb38x_ms_host *host,
+static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
 					    unsigned char *buf,
 					    unsigned int length)
 {
@@ -86,7 +86,7 @@ static unsigned int jmb38x_ms_read_reg_data(struct jmb38x_ms_host *host,
 	return off;
 }
 
-static unsigned int jmb38x_ms_write_data(struct jmb38x_ms_host *host,
+static unsigned int j38ms_write_data(struct j38ms_host *host,
 					 unsigned char *buf,
 					 unsigned int length)
 {
@@ -139,7 +139,7 @@ static unsigned int jmb38x_ms_write_data(struct jmb38x_ms_host *host,
 	return off;
 }
 
-static unsigned int jmb38x_ms_write_reg_data(struct jmb38x_ms_host *host,
+static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
 					     unsigned char *buf,
 					     unsigned int length)
 {
@@ -165,7 +165,7 @@ static unsigned int jmb38x_ms_write_reg_data(struct jmb38x_ms_host *host,
 	return off;
 }
 
-static int jmb38x_ms_transfer_data(struct jmb38x_ms_host *host)
+static int j38ms_transfer_data(struct j38ms_host *host)
 {
 	unsigned int length;
 	unsigned int off;
@@ -201,12 +201,12 @@ static int jmb38x_ms_transfer_data(struct jmb38x_ms_host *host)
 
 		if (host->req->data_dir == WRITE)
 			t_size = !(host->cmd_flags & REG_DATA)
-				 ? jmb38x_ms_write_data(host, buf, p_cnt)
-				 : jmb38x_ms_write_reg_data(host, buf, p_cnt);
+				 ? j38ms_write_data(host, buf, p_cnt)
+				 : j38ms_write_reg_data(host, buf, p_cnt);
 		else
 			t_size = !(host->cmd_flags & REG_DATA)
-				 ? jmb38x_ms_read_data(host, buf, p_cnt)
-				 : jmb38x_ms_read_reg_data(host, buf, p_cnt);
+				 ? j38ms_read_data(host, buf, p_cnt)
+				 : j38ms_read_reg_data(host, buf, p_cnt);
 
 		if (host->req->long_data) {
 			kunmap_atomic(buf - p_off, KM_BIO_SRC_IRQ);
@@ -232,9 +232,9 @@ static int jmb38x_ms_transfer_data(struct jmb38x_ms_host *host)
 	return length;
 }
 
-static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
+static int j38ms_issue_cmd(struct memstick_host *msh)
 {
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 	unsigned char *data;
 	unsigned int data_len, cmd, t_val;
 
@@ -313,7 +313,7 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
 		cmd |= data_len & 0xf;
 
 		if (host->req->data_dir == WRITE) {
-			jmb38x_ms_transfer_data(host);
+			j38ms_transfer_data(host);
 			writel(host->io_word[0], host->addr + TPC_P0);
 			writel(host->io_word[1], host->addr + TPC_P1);
 		}
@@ -330,9 +330,9 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
 	return 0;
 }
 
-static void jmb38x_ms_complete_cmd(struct memstick_host *msh, int last)
+static void j38ms_complete_cmd(struct memstick_host *msh, int last)
 {
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 	unsigned int t_val = 0;
 	int rc;
 
@@ -370,7 +370,7 @@ static void jmb38x_ms_complete_cmd(struct memstick_host *msh, int last)
 	if (!last) {
 		do {
 			rc = memstick_next_req(msh, &host->req);
-		} while (!rc && jmb38x_ms_issue_cmd(msh));
+		} while (!rc && j38ms_issue_cmd(msh));
 	} else {
 		do {
 			rc = memstick_next_req(msh, &host->req);
@@ -380,10 +380,10 @@ static void jmb38x_ms_complete_cmd(struct memstick_host *msh, int last)
 	}
 }
 
-static irqreturn_t jmb38x_ms_isr(int irq, void *dev_id)
+static irqreturn_t j38ms_isr(int irq, void *dev_id)
 {
 	struct memstick_host *msh = dev_id;
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 	unsigned int irq_status;
 
 	spin_lock(&host->lock);
@@ -407,10 +407,10 @@ static irqreturn_t jmb38x_ms_isr(int irq, void *dev_id)
 			} else {
 				if (irq_status & (INT_STATUS_FIFO_RRDY
 						  | INT_STATUS_FIFO_WRDY))
-					jmb38x_ms_transfer_data(host);
+					j38ms_transfer_data(host);
 
 				if (irq_status & INT_STATUS_EOTRAN) {
-					jmb38x_ms_transfer_data(host);
+					j38ms_transfer_data(host);
 					host->cmd_flags |= FIFO_READY;
 				}
 			}
@@ -427,7 +427,7 @@ static irqreturn_t jmb38x_ms_isr(int irq, void *dev_id)
 								+ TPC_P1);
 						host->io_pos = 8;
 
-						jmb38x_ms_transfer_data(host);
+						j38ms_transfer_data(host);
 					}
 					host->cmd_flags |= FIFO_READY;
 				}
@@ -446,31 +446,31 @@ static irqreturn_t jmb38x_ms_isr(int irq, void *dev_id)
 	    && (((host->cmd_flags & CMD_READY)
 		 && (host->cmd_flags & FIFO_READY))
 		|| host->req->error))
-		jmb38x_ms_complete_cmd(msh, 0);
+		j38ms_complete_cmd(msh, 0);
 
 	spin_unlock(&host->lock);
 	return IRQ_HANDLED;
 }
 
-static void jmb38x_ms_abort(unsigned long data)
+static void j38ms_abort(unsigned long data)
 {
 	struct memstick_host *msh = (struct memstick_host *)data;
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 	unsigned long flags;
 
 	dev_dbg(&host->chip->pdev->dev, "abort\n");
 	spin_lock_irqsave(&host->lock, flags);
 	if (host->req) {
 		host->req->error = -ETIME;
-		jmb38x_ms_complete_cmd(msh, 0);
+		j38ms_complete_cmd(msh, 0);
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void jmb38x_ms_req_tasklet(unsigned long data)
+static void j38ms_req_tasklet(unsigned long data)
 {
 	struct memstick_host *msh = (struct memstick_host *)data;
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 	unsigned long flags;
 	int rc;
 
@@ -479,24 +479,24 @@ static void jmb38x_ms_req_tasklet(unsigned long data)
 		do {
 			rc = memstick_next_req(msh, &host->req);
 			dev_dbg(&host->chip->pdev->dev, "tasklet req %d\n", rc);
-		} while (!rc && jmb38x_ms_issue_cmd(msh));
+		} while (!rc && j38ms_issue_cmd(msh));
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void jmb38x_ms_dummy_submit(struct memstick_host *msh)
+static void j38ms_dummy_submit(struct memstick_host *msh)
 {
 	return;
 }
 
-static void jmb38x_ms_submit_req(struct memstick_host *msh)
+static void j38ms_submit_req(struct memstick_host *msh)
 {
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 
 	tasklet_schedule(&host->notify);
 }
 
-static int jmb38x_ms_reset(struct jmb38x_ms_host *host)
+static int j38ms_reset(struct j38ms_host *host)
 {
 	int cnt;
 
@@ -538,11 +538,11 @@ reset_ok:
 	return 0;
 }
 
-static int jmb38x_ms_set_param(struct memstick_host *msh,
+static int j38ms_set_param(struct memstick_host *msh,
 			       enum memstick_param param,
 			       int value)
 {
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 	unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
 	unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0;
 	int rc = 0;
@@ -550,7 +550,7 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
 	switch (param) {
 	case MEMSTICK_POWER:
 		if (value == MEMSTICK_POWER_ON) {
-			rc = jmb38x_ms_reset(host);
+			rc = j38ms_reset(host);
 			if (rc)
 				return rc;
 
@@ -623,9 +623,9 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
 
 #ifdef CONFIG_PM
 
-static int jmb38x_ms_suspend(struct pci_dev *dev, pm_message_t state)
+static int j38ms_suspend(struct pci_dev *dev, pm_message_t state)
 {
-	struct jmb38x_ms *jm = pci_get_drvdata(dev);
+	struct j38ms *jm = pci_get_drvdata(dev);
 	int cnt;
 
 	for (cnt = 0; cnt < jm->host_cnt; ++cnt) {
@@ -641,9 +641,9 @@ static int jmb38x_ms_suspend(struct pci_dev *dev, pm_message_t state)
 	return 0;
 }
 
-static int jmb38x_ms_resume(struct pci_dev *dev)
+static int j38ms_resume(struct pci_dev *dev)
 {
-	struct jmb38x_ms *jm = pci_get_drvdata(dev);
+	struct j38ms *jm = pci_get_drvdata(dev);
 	int rc;
 
 	pci_set_power_state(dev, PCI_D0);
@@ -668,12 +668,12 @@ static int jmb38x_ms_resume(struct pci_dev *dev)
 
 #else
 
-#define jmb38x_ms_suspend NULL
-#define jmb38x_ms_resume NULL
+#define j38ms_suspend NULL
+#define j38ms_resume NULL
 
 #endif /* CONFIG_PM */
 
-static int jmb38x_ms_count_slots(struct pci_dev *pdev)
+static int j38ms_count_slots(struct pci_dev *pdev)
 {
 	int cnt, rc = 0;
 
@@ -689,12 +689,12 @@ static int jmb38x_ms_count_slots(struct pci_dev *pdev)
 	return rc;
 }
 
-static struct memstick_host *jmb38x_ms_alloc_host(struct jmb38x_ms *jm, int cnt)
+static struct memstick_host *j38ms_alloc_host(struct j38ms *jm, int cnt)
 {
 	struct memstick_host *msh;
-	struct jmb38x_ms_host *host;
+	struct j38ms_host *host;
 
-	msh = memstick_alloc_host(sizeof(struct jmb38x_ms_host),
+	msh = memstick_alloc_host(sizeof(struct j38ms_host),
 				  &jm->pdev->dev);
 	if (!msh)
 		return NULL;
@@ -713,15 +713,15 @@ static struct memstick_host *jmb38x_ms_alloc_host(struct jmb38x_ms *jm, int cnt)
 	host->irq = jm->pdev->irq;
 	host->timeout_jiffies = msecs_to_jiffies(1000);
 
-	tasklet_init(&host->notify, jmb38x_ms_req_tasklet, (unsigned long)msh);
-	msh->request = jmb38x_ms_submit_req;
-	msh->set_param = jmb38x_ms_set_param;
+	tasklet_init(&host->notify, j38ms_req_tasklet, (unsigned long)msh);
+	msh->request = j38ms_submit_req;
+	msh->set_param = j38ms_set_param;
 
 	msh->caps = MEMSTICK_CAP_PAR4 | MEMSTICK_CAP_PAR8;
 
-	setup_timer(&host->timer, jmb38x_ms_abort, (unsigned long)msh);
+	setup_timer(&host->timer, j38ms_abort, (unsigned long)msh);
 
-	if (!request_irq(host->irq, jmb38x_ms_isr, IRQF_SHARED, host->host_id,
+	if (!request_irq(host->irq, j38ms_isr, IRQF_SHARED, host->host_id,
 			 msh))
 		return msh;
 
@@ -731,19 +731,19 @@ err_out_free:
 	return NULL;
 }
 
-static void jmb38x_ms_free_host(struct memstick_host *msh)
+static void j38ms_free_host(struct memstick_host *msh)
 {
-	struct jmb38x_ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = memstick_priv(msh);
 
 	free_irq(host->irq, msh);
 	iounmap(host->addr);
 	memstick_free_host(msh);
 }
 
-static int jmb38x_ms_probe(struct pci_dev *pdev,
+static int j38ms_probe(struct pci_dev *pdev,
 			   const struct pci_device_id *dev_id)
 {
-	struct jmb38x_ms *jm;
+	struct j38ms *jm;
 	int pci_dev_busy = 0;
 	int rc, cnt;
 
@@ -766,14 +766,14 @@ static int jmb38x_ms_probe(struct pci_dev *pdev,
 	pci_read_config_dword(pdev, 0xac, &rc);
 	pci_write_config_dword(pdev, 0xac, rc | 0x00470000);
 
-	cnt = jmb38x_ms_count_slots(pdev);
+	cnt = j38ms_count_slots(pdev);
 	if (!cnt) {
 		rc = -ENODEV;
 		pci_dev_busy = 1;
 		goto err_out;
 	}
 
-	jm = kzalloc(sizeof(struct jmb38x_ms)
+	jm = kzalloc(sizeof(struct j38ms)
 		     + cnt * sizeof(struct memstick_host *), GFP_KERNEL);
 	if (!jm) {
 		rc = -ENOMEM;
@@ -785,14 +785,14 @@ static int jmb38x_ms_probe(struct pci_dev *pdev,
 	pci_set_drvdata(pdev, jm);
 
 	for (cnt = 0; cnt < jm->host_cnt; ++cnt) {
-		jm->hosts[cnt] = jmb38x_ms_alloc_host(jm, cnt);
+		jm->hosts[cnt] = j38ms_alloc_host(jm, cnt);
 		if (!jm->hosts[cnt])
 			break;
 
 		rc = memstick_add_host(jm->hosts[cnt]);
 
 		if (rc) {
-			jmb38x_ms_free_host(jm->hosts[cnt]);
+			j38ms_free_host(jm->hosts[cnt]);
 			jm->hosts[cnt] = NULL;
 			break;
 		}
@@ -813,10 +813,10 @@ err_out:
 	return rc;
 }
 
-static void jmb38x_ms_remove(struct pci_dev *dev)
+static void j38ms_remove(struct pci_dev *dev)
 {
-	struct jmb38x_ms *jm = pci_get_drvdata(dev);
-	struct jmb38x_ms_host *host;
+	struct j38ms *jm = pci_get_drvdata(dev);
+	struct j38ms_host *host;
 	int cnt;
 	unsigned long flags;
 
@@ -826,7 +826,7 @@ static void jmb38x_ms_remove(struct pci_dev *dev)
 
 		host = memstick_priv(jm->hosts[cnt]);
 
-		jm->hosts[cnt]->request = jmb38x_ms_dummy_submit;
+		jm->hosts[cnt]->request = j38ms_dummy_submit;
 		tasklet_kill(&host->notify);
 		writel(0, host->addr + INT_SIGNAL_ENABLE);
 		writel(0, host->addr + INT_STATUS_ENABLE);
@@ -835,14 +835,14 @@ static void jmb38x_ms_remove(struct pci_dev *dev)
 		spin_lock_irqsave(&host->lock, flags);
 		if (host->req) {
 			host->req->error = -ETIME;
-			jmb38x_ms_complete_cmd(jm->hosts[cnt], 1);
+			j38ms_complete_cmd(jm->hosts[cnt], 1);
 		}
 		spin_unlock_irqrestore(&host->lock, flags);
 
 		memstick_remove_host(jm->hosts[cnt]);
 		dev_dbg(&jm->pdev->dev, "host removed\n");
 
-		jmb38x_ms_free_host(jm->hosts[cnt]);
+		j38ms_free_host(jm->hosts[cnt]);
 	}
 
 	pci_set_drvdata(dev, NULL);
@@ -851,39 +851,39 @@ static void jmb38x_ms_remove(struct pci_dev *dev)
 	kfree(jm);
 }
 
-static struct pci_device_id jmb38x_ms_id_tbl [] = {
+static struct pci_device_id j38ms_id_tbl[] = {
 	{ PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB38X_MS, PCI_ANY_ID,
 	  PCI_ANY_ID, 0, 0, 0 },
 	{ }
 };
 
-static struct pci_driver jmb38x_ms_driver = {
+static struct pci_driver j38ms_driver = {
 	.name = DRIVER_NAME,
-	.id_table = jmb38x_ms_id_tbl,
-	.probe = jmb38x_ms_probe,
-	.remove = jmb38x_ms_remove,
-	.suspend = jmb38x_ms_suspend,
-	.resume = jmb38x_ms_resume
+	.id_table = j38ms_id_tbl,
+	.probe = j38ms_probe,
+	.remove = j38ms_remove,
+	.suspend = j38ms_suspend,
+	.resume = j38ms_resume
 };
 
-static int __init jmb38x_ms_init(void)
+static int __init j38ms_init(void)
 {
-	return pci_register_driver(&jmb38x_ms_driver);
+	return pci_register_driver(&j38ms_driver);
 }
 
-static void __exit jmb38x_ms_exit(void)
+static void __exit j38ms_exit(void)
 {
-	pci_unregister_driver(&jmb38x_ms_driver);
+	pci_unregister_driver(&j38ms_driver);
 }
 
 MODULE_AUTHOR("Alex Dubov");
 MODULE_DESCRIPTION("JMicron jmb38x MemoryStick driver");
 MODULE_LICENSE("GPL");
-MODULE_DEVICE_TABLE(pci, jmb38x_ms_id_tbl);
+MODULE_DEVICE_TABLE(pci, j38ms_id_tbl);
 
 module_param(no_dma, bool, S_IRUGO);
 module_param(debug, bool, S_IRUGO);
 
 
-module_init(jmb38x_ms_init);
-module_exit(jmb38x_ms_exit);
+module_init(j38ms_init);
+module_exit(j38ms_exit);
drivers/memstick/host/jmb38x_ms.h +3 -3
index 5bca4b3..c64f2e1 100644
@@ -142,8 +142,8 @@
 #define PCI_CTL_CLOCK_DLY_MASK_A 0x00000f00
 #define PCI_CTL_CLOCK_DLY_MASK_B 0x0000f000
 
-struct jmb38x_ms_host {
-	struct jmb38x_ms        *chip;
+struct j38ms_host {
+	struct j38ms            *chip;
 	void __iomem            *addr;
 	spinlock_t              lock;
 	struct tasklet_struct   notify;
@@ -159,7 +159,7 @@ struct jmb38x_ms_host {
 	unsigned int            io_word[2];
 };
 
-struct jmb38x_ms {
+struct j38ms {
 	struct pci_dev        *pdev;
 	int                   host_cnt;
 	struct memstick_host  *hosts[];
Signature · 1 line
1.7.1
maintainer
#47 lore raw

Re: [PATCH 16/29] memstick: jmb38x_ms: s/jmb38x_ms/j38ms/g

Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 16/29] memstick: jmb38x_ms: s/jmb38x_ms/j38ms/g
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This just makes it easier to type
function names
while still keeping the meaning
Driver name and filenames are left unchanged.

Quoted 2 lines

---

What sort of patch/argument is this?
Function prefix should match the module name, to be immediately and unambiguously identifiable in the stack trace.

author maintainer
#48 lore raw

Re: [PATCH 16/29] memstick: jmb38x_ms: s/jmb38x_ms/j38ms/g

Quoted 14 lines · Alex Dubov
Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 16/29] memstick: jmb38x_ms: s/jmb38x_ms/j38ms/g
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This just makes it easier to type
function names
while still keeping the meaning
Driver name and filenames are left unchanged.

Quoted 6 lines
Quoted 2 lines

---

What sort of patch/argument is this?
Function prefix should match the module name, to be immediately and unambiguously identifiable in the stack trace.

In that case maybe rename the module too? 'jmb38x_ms' is just a mouthful as Andrew Morton would say.

I mean if you really really dislike that, I could revert it, but for peoples sake, whats wrong with that?

Best regards,
Maxim Levitsky

author maintainer
#49 lore raw

PATCH 17/29 memstick: jmb38x_ms: move "reg_data" functions together.

In reply to Maxim Levitsky

No functional changes, just group these funtions together.

---
 drivers/memstick/host/jmb38x_ms.c |  104 ++++++++++++++++++------------------
 drivers/memstick/host/jmb38x_ms.h |    8 +++
 2 files changed, 60 insertions(+), 52 deletions(-)
drivers/memstick/host/jmb38x_ms.c +52 -52
index e896a4d..2e10104 100644
@@ -60,32 +60,6 @@ static unsigned int j38ms_read_data(struct j38ms_host *host,
 	return off;
 }
 
-static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
-					    unsigned char *buf,
-					    unsigned int length)
-{
-	unsigned int off = 0;
-
-	while (host->io_pos > 4 && length) {
-		buf[off++] = host->io_word[0] & 0xff;
-		host->io_word[0] >>= 8;
-		length--;
-		host->io_pos--;
-	}
-
-	if (!length)
-		return off;
-
-	while (host->io_pos && length) {
-		buf[off++] = host->io_word[1] & 0xff;
-		host->io_word[1] >>= 8;
-		length--;
-		host->io_pos--;
-	}
-
-	return off;
-}
-
 static unsigned int j38ms_write_data(struct j38ms_host *host,
 					 unsigned char *buf,
 					 unsigned int length)
@@ -139,32 +113,6 @@ static unsigned int j38ms_write_data(struct j38ms_host *host,
 	return off;
 }
 
-static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
-					     unsigned char *buf,
-					     unsigned int length)
-{
-	unsigned int off = 0;
-
-	while (host->io_pos < 4 && length) {
-		host->io_word[0] &= ~(0xff << (host->io_pos * 8));
-		host->io_word[0] |=  buf[off++] << (host->io_pos * 8);
-		host->io_pos++;
-		length--;
-	}
-
-	if (!length)
-		return off;
-
-	while (host->io_pos < 8 && length) {
-		host->io_word[1] &= ~(0xff << (host->io_pos * 8));
-		host->io_word[1] |=  buf[off++] << (host->io_pos * 8);
-		host->io_pos++;
-		length--;
-	}
-
-	return off;
-}
-
 static int j38ms_transfer_data(struct j38ms_host *host)
 {
 	unsigned int length;
@@ -232,6 +180,58 @@ static int j38ms_transfer_data(struct j38ms_host *host)
 	return length;
 }
 
+static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
+					    unsigned char *buf,
+					    unsigned int length)
+{
+	unsigned int off = 0;
+
+	while (host->io_pos > 4 && length) {
+		buf[off++] = host->io_word[0] & 0xff;
+		host->io_word[0] >>= 8;
+		length--;
+		host->io_pos--;
+	}
+
+	if (!length)
+		return off;
+
+	while (host->io_pos && length) {
+		buf[off++] = host->io_word[1] & 0xff;
+		host->io_word[1] >>= 8;
+		length--;
+		host->io_pos--;
+	}
+
+	return off;
+}
+
+static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
+					     unsigned char *buf,
+					     unsigned int length)
+{
+	unsigned int off = 0;
+
+	while (host->io_pos < 4 && length) {
+		host->io_word[0] &= ~(0xff << (host->io_pos * 8));
+		host->io_word[0] |=  buf[off++] << (host->io_pos * 8);
+		host->io_pos++;
+		length--;
+	}
+
+	if (!length)
+		return off;
+
+	while (host->io_pos < 8 && length) {
+		host->io_word[1] &= ~(0xff << (host->io_pos * 8));
+		host->io_word[1] |=  buf[off++] << (host->io_pos * 8);
+		host->io_pos++;
+		length--;
+	}
+
+	return off;
+}
+
 static int j38ms_issue_cmd(struct memstick_host *msh)
 {
 	struct j38ms_host *host = memstick_priv(msh);
drivers/memstick/host/jmb38x_ms.h +8 -0
index c64f2e1..a940b5d 100644
@@ -186,3 +186,11 @@ enum {
 #define dbg(host, format, ...)		__dbg(host, 1, format, ## __VA_ARGS__)
 #define dbg_v(host, format, ...)	__dbg(host, 2, format, ## __VA_ARGS__)
 #define dbg_reg(host, format, ...)	__dbg(host, 3, format, ## __VA_ARGS__)
+
+static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
+					    unsigned char *buf,
+					    unsigned int length);
+
+static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
+					     unsigned char *buf,
+					     unsigned int length);
Signature · 1 line
1.7.1
maintainer
#50 lore raw

Re: [PATCH 17/29] memstick: jmb38x_ms: move "reg_data" functions together.

Quoted 10 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 17/29] memstick: jmb38x_ms: move "reg_data" functions together.
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
No functional changes, just group
these funtions together.

---

As before, patch with dubious utility.

author maintainer
#51 lore raw

Re: [PATCH 17/29] memstick: jmb38x_ms: move "reg_data" functions together.

Quoted 11 lines · Alex Dubov
Quoted 8 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 17/29] memstick: jmb38x_ms: move "reg_data" functions together.
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
No functional changes, just group
these funtions together.

Quoted 4 lines
Quoted 2 lines

---

As before, patch with dubious utility.

But no harm ether, no?

Just makes code a bit easier to read.
Again that patch was done to minimize diff w/original when I was splitting patches.
If you really are againt it, I can revert that.

Best regards,
Maxim Levitsky

author maintainer
#52 lore raw

PATCH 18/29 memstick: jmb38x_ms: rename functions

In reply to Maxim Levitsky

Give functions names that I hope will describe them better. Its a matter of personal taste somewhat, I admit.

---
 drivers/memstick/host/jmb38x_ms.c |   38 ++++++++++++++++++------------------
 drivers/memstick/host/jmb38x_ms.h |    4 +-
 2 files changed, 21 insertions(+), 21 deletions(-)
drivers/memstick/host/jmb38x_ms.c +19 -19
index 2e10104..295f755 100644
@@ -22,7 +22,7 @@
 static int no_dma;
 static int debug;
 
-static unsigned int j38ms_read_data(struct j38ms_host *host,
+static unsigned int j38ms_read_fifo_pio(struct j38ms_host *host,
 					unsigned char *buf, unsigned int length)
 {
 	unsigned int off = 0;
@@ -60,7 +60,7 @@ static unsigned int j38ms_read_data(struct j38ms_host *host,
 	return off;
 }
 
-static unsigned int j38ms_write_data(struct j38ms_host *host,
+static unsigned int j38ms_write_fifo_pio(struct j38ms_host *host,
 					 unsigned char *buf,
 					 unsigned int length)
 {
@@ -149,12 +149,12 @@ static int j38ms_transfer_data(struct j38ms_host *host)
 
 		if (host->req->data_dir == WRITE)
 			t_size = !(host->cmd_flags & REG_DATA)
-				 ? j38ms_write_data(host, buf, p_cnt)
-				 : j38ms_write_reg_data(host, buf, p_cnt);
+				 ? j38ms_write_fifo_pio(host, buf, p_cnt)
+				 : j38ms_write_tpc_inline(host, buf, p_cnt);
 		else
 			t_size = !(host->cmd_flags & REG_DATA)
-				 ? j38ms_read_data(host, buf, p_cnt)
-				 : j38ms_read_reg_data(host, buf, p_cnt);
+				 ? j38ms_read_fifo_pio(host, buf, p_cnt)
+				 : j38ms_read_tpc_inline(host, buf, p_cnt);
 
 		if (host->req->long_data) {
 			kunmap_atomic(buf - p_off, KM_BIO_SRC_IRQ);
@@ -180,7 +180,7 @@ static int j38ms_transfer_data(struct j38ms_host *host)
 	return length;
 }
 
-static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
+static unsigned int j38ms_read_tpc_inline(struct j38ms_host *host,
 					    unsigned char *buf,
 					    unsigned int length)
 {
@@ -206,7 +206,7 @@ static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
 	return off;
 }
 
-static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
+static unsigned int j38ms_write_tpc_inline(struct j38ms_host *host,
 					     unsigned char *buf,
 					     unsigned int length)
 {
@@ -232,7 +232,7 @@ static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
 	return off;
 }
 
-static int j38ms_issue_cmd(struct memstick_host *msh)
+static int j38ms_execute_tpc(struct memstick_host *msh)
 {
 	struct j38ms_host *host = memstick_priv(msh);
 	unsigned char *data;
@@ -330,7 +330,7 @@ static int j38ms_issue_cmd(struct memstick_host *msh)
 	return 0;
 }
 
-static void j38ms_complete_cmd(struct memstick_host *msh, int last)
+static void j38ms_complete_tpc(struct memstick_host *msh, int last)
 {
 	struct j38ms_host *host = memstick_priv(msh);
 	unsigned int t_val = 0;
@@ -370,7 +370,7 @@ static void j38ms_complete_cmd(struct memstick_host *msh, int last)
 	if (!last) {
 		do {
 			rc = memstick_next_req(msh, &host->req);
-		} while (!rc && j38ms_issue_cmd(msh));
+		} while (!rc && j38ms_execute_tpc(msh));
 	} else {
 		do {
 			rc = memstick_next_req(msh, &host->req);
@@ -446,13 +446,13 @@ static irqreturn_t j38ms_isr(int irq, void *dev_id)
 	    && (((host->cmd_flags & CMD_READY)
 		 && (host->cmd_flags & FIFO_READY))
 		|| host->req->error))
-		j38ms_complete_cmd(msh, 0);
+		j38ms_complete_tpc(msh, 0);
 
 	spin_unlock(&host->lock);
 	return IRQ_HANDLED;
 }
 
-static void j38ms_abort(unsigned long data)
+static void j38ms_irq_timeout(unsigned long data)
 {
 	struct memstick_host *msh = (struct memstick_host *)data;
 	struct j38ms_host *host = memstick_priv(msh);
@@ -462,12 +462,12 @@ static void j38ms_abort(unsigned long data)
 	spin_lock_irqsave(&host->lock, flags);
 	if (host->req) {
 		host->req->error = -ETIME;
-		j38ms_complete_cmd(msh, 0);
+		j38ms_complete_tpc(msh, 0);
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void j38ms_req_tasklet(unsigned long data)
+static void j38ms_submit_tasklet(unsigned long data)
 {
 	struct memstick_host *msh = (struct memstick_host *)data;
 	struct j38ms_host *host = memstick_priv(msh);
@@ -479,7 +479,7 @@ static void j38ms_req_tasklet(unsigned long data)
 		do {
 			rc = memstick_next_req(msh, &host->req);
 			dev_dbg(&host->chip->pdev->dev, "tasklet req %d\n", rc);
-		} while (!rc && j38ms_issue_cmd(msh));
+		} while (!rc && j38ms_execute_tpc(msh));
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 }
@@ -713,13 +713,13 @@ static struct memstick_host *j38ms_alloc_host(struct j38ms *jm, int cnt)
 	host->irq = jm->pdev->irq;
 	host->timeout_jiffies = msecs_to_jiffies(1000);
 
-	tasklet_init(&host->notify, j38ms_req_tasklet, (unsigned long)msh);
+	tasklet_init(&host->notify, j38ms_submit_tasklet, (unsigned long)msh);
 	msh->request = j38ms_submit_req;
 	msh->set_param = j38ms_set_param;
 
 	msh->caps = MEMSTICK_CAP_PAR4 | MEMSTICK_CAP_PAR8;
 
-	setup_timer(&host->timer, j38ms_abort, (unsigned long)msh);
+	setup_timer(&host->timer, j38ms_irq_timeout, (unsigned long)msh);
 
 	if (!request_irq(host->irq, j38ms_isr, IRQF_SHARED, host->host_id,
 			 msh))
@@ -835,7 +835,7 @@ static void j38ms_remove(struct pci_dev *dev)
 		spin_lock_irqsave(&host->lock, flags);
 		if (host->req) {
 			host->req->error = -ETIME;
-			j38ms_complete_cmd(jm->hosts[cnt], 1);
+			j38ms_complete_tpc(jm->hosts[cnt], 1);
 		}
 		spin_unlock_irqrestore(&host->lock, flags);
 
drivers/memstick/host/jmb38x_ms.h +2 -2
index a940b5d..44e1fc1 100644
@@ -187,10 +187,10 @@ enum {
 #define dbg_v(host, format, ...)	__dbg(host, 2, format, ## __VA_ARGS__)
 #define dbg_reg(host, format, ...)	__dbg(host, 3, format, ## __VA_ARGS__)
 
-static unsigned int j38ms_read_reg_data(struct j38ms_host *host,
+static unsigned int j38ms_read_tpc_inline(struct j38ms_host *host,
 					    unsigned char *buf,
 					    unsigned int length);
 
-static unsigned int j38ms_write_reg_data(struct j38ms_host *host,
+static unsigned int j38ms_write_tpc_inline(struct j38ms_host *host,
 					     unsigned char *buf,
 					     unsigned int length);
Signature · 1 line
1.7.1
maintainer
#53 lore raw

Re: [PATCH 18/29] memstick: jmb38x_ms: rename functions

Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 18/29] memstick: jmb38x_ms: rename functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Give functions names that I hope will
describe them better.
Its a matter of personal taste somewhat, I admit.

---

Just like 2/3 of your patches in this pack, until now.

author maintainer
#54 lore raw

Re: [PATCH 18/29] memstick: jmb38x_ms: rename functions

Quoted 12 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 18/29] memstick: jmb38x_ms: rename functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Give functions names that I hope will
describe them better.
Its a matter of personal taste somewhat, I admit.

Quoted 4 lines
Quoted 2 lines

---

Just like 2/3 of your patches in this pack, until now.

And about 90% of patches that go to kernel no?

Besides again, that was done to minimize diff, and I made _pio postfixes to make clear that functions are used for PIO.

Best regards,
Maxim Levitsky

author maintainer
#55 lore raw

PATCH 19/29 memstick: jmb38x_ms: add register read/write functions

In reply to Maxim Levitsky

All over the code it is a bit easier to see the register access with this patch. Also set/clear mask helpers refactor code a bit, but the biggest reason for this patch is to make it possible to trace register read/writes with a flip of a module param.

Currently these functions are unused, but will be by later code

---
 drivers/memstick/host/jmb38x_ms.c |  102 ++++++++++++++++++++++++++++++++++++-
 drivers/memstick/host/jmb38x_ms.h |    1 +
 2 files changed, 102 insertions(+), 1 deletions(-)
drivers/memstick/host/jmb38x_ms.c +101 -1
index 295f755..bcdb785 100644
@@ -22,8 +22,86 @@
 static int no_dma;
 static int debug;
 
+/* Read a register*/
+static inline u32 j38ms_read_reg(struct j38ms_host *host, int address)
+{
+	u32 value =  readl(host->addr + address);
+	dbg_reg(host, "reg 0x%02x == 0x%08x", address, value);
+	return value;
+}
+
+/* Write a register */
+static inline void j38ms_write_reg(struct j38ms_host *host,
+						int address, u32 value)
+{
+	dbg_reg(host, "reg 0x%02x <- 0x%08x", address, cpu_to_le32(value));
+	writel(value, host->addr + address);
+}
+
+/* Read a register without endiannes conversion*/
+static inline u32 j38ms_read_reg_raw(struct j38ms_host *host, int address)
+{
+	u32 value =  __raw_readl(host->addr + address);
+	dbg_reg(host, "reg 0x%02x == 0x%08x", address, cpu_to_le32(value));
+	return value;
+}
+
+/* Write a register without endiannes conversion */
+static inline void j38ms_write_reg_raw(struct j38ms_host *host,
+						int address, u32 value)
+{
+	dbg_reg(host, "reg 0x%02x <- 0x%08x", address, value);
+	__raw_writel(value, host->addr + address);
+}
+
+/* Set specific bits in a register*/
+static inline void j38ms_set_reg_mask(struct j38ms_host *host,
+						int address, u32 mask)
+{
+	u32 reg = readl(host->addr + address);
+	dbg_reg(host, "reg 0x%02x |= 0x%08x (old =0x%08x)", address, mask, reg);
+	writel(reg | mask , host->addr + address);
+}
+
+/* Clear specific bits in a register*/
+static inline void j38ms_clear_reg_mask(struct j38ms_host *host,
+						int address, u32 mask)
+{
+	u32 reg = readl(host->addr + address);
+	dbg_reg(host, "reg 0x%02x &= 0x%08x (old = 0x%08x, mask = 0x%08x)",
+						address, ~mask, reg, mask);
+	writel(reg & ~mask, host->addr + address);
+}
+
+/* Reads one DWORD via PIO. returns -EAGAIN if fifo is empty */
+static inline int j38ms_read_fifo_dword_pio(struct j38ms_host *host, u32 *dword)
+{
+	if (unlikely(j38ms_read_reg(host, STATUS) & STATUS_FIFO_EMPTY)) {
+		dbg(host, "PIO: FIFO empty");
+		return -EAGAIN;
+	}
+
+	*dword = j38ms_read_reg_raw(host, DATA);
+	dbg(host, "PIO: read: %08x", *dword);
+	return 0;
+}
+
+/* Writes one DWORD via PIO. returns -EAGAIN if fifo is full */
+static inline int j38ms_write_fifo_dword_pio(struct j38ms_host *host, u32 dword)
+{
+	if (unlikely(j38ms_read_reg(host, STATUS) & STATUS_FIFO_FULL)) {
+		dbg(host, "PIO: FIFO full");
+		return -EAGAIN;
+	}
+
+	dbg(host, "PIO: writing: %08x", dword);
+	j38ms_write_reg_raw(host, DATA, dword);
+	return 0;
+}
+
+/* Read TPC data using PIO */
 static unsigned int j38ms_read_fifo_pio(struct j38ms_host *host,
-					unsigned char *buf, unsigned int length)
+				unsigned char *buf, unsigned int length)
 {
 	unsigned int off = 0;
 
@@ -60,6 +138,7 @@ static unsigned int j38ms_read_fifo_pio(struct j38ms_host *host,
 	return off;
 }
 
+/* Write TPC data through normal PIO fifo */
 static unsigned int j38ms_write_fifo_pio(struct j38ms_host *host,
 					 unsigned char *buf,
 					 unsigned int length)
@@ -113,6 +192,7 @@ static unsigned int j38ms_write_fifo_pio(struct j38ms_host *host,
 	return off;
 }
 
+/* Transfer data between current request and FIFO */
 static int j38ms_transfer_data(struct j38ms_host *host)
 {
 	unsigned int length;
@@ -180,6 +260,7 @@ static int j38ms_transfer_data(struct j38ms_host *host)
 	return length;
 }
 
+/* Read short TPC data (up to 8 bytes) via 2 special registers*/
 static unsigned int j38ms_read_tpc_inline(struct j38ms_host *host,
 					    unsigned char *buf,
 					    unsigned int length)
@@ -206,6 +287,7 @@ static unsigned int j38ms_read_tpc_inline(struct j38ms_host *host,
 	return off;
 }
 
+/* Write short TPC data (up to 8 bytes) through 2 special registers */
 static unsigned int j38ms_write_tpc_inline(struct j38ms_host *host,
 					     unsigned char *buf,
 					     unsigned int length)
@@ -232,6 +314,19 @@ static unsigned int j38ms_write_tpc_inline(struct j38ms_host *host,
 	return off;
 }
 
+/*
+ * Start execution of a TPC:
+ * NOTES:
+ *
+ * PIO writes trigger wierd hardware bug that causes DMA writes
+ *  to fail.
+ *
+ * length alignmemt:
+ *	Short (<=8) TPC don't have any alignment problems.
+ *	DMA read/writes must be 4 aligned
+ *	PIO _reads_ must be aligned. Writes can be not aligned
+ *
+ */
 static int j38ms_execute_tpc(struct memstick_host *msh)
 {
 	struct j38ms_host *host = memstick_priv(msh);
@@ -330,6 +425,7 @@ static int j38ms_execute_tpc(struct memstick_host *msh)
 	return 0;
 }
 
+/* Cleanups execution of current TPC */
 static void j38ms_complete_tpc(struct memstick_host *msh, int last)
 {
 	struct j38ms_host *host = memstick_priv(msh);
@@ -380,6 +476,7 @@ static void j38ms_complete_tpc(struct memstick_host *msh, int last)
 	}
 }
 
+/* Interrupt handler */
 static irqreturn_t j38ms_isr(int irq, void *dev_id)
 {
 	struct memstick_host *msh = dev_id;
@@ -452,6 +549,7 @@ static irqreturn_t j38ms_isr(int irq, void *dev_id)
 	return IRQ_HANDLED;
 }
 
+/* Timer that is executed in absense of the interrupt */
 static void j38ms_irq_timeout(unsigned long data)
 {
 	struct memstick_host *msh = (struct memstick_host *)data;
@@ -496,6 +594,7 @@ static void j38ms_submit_req(struct memstick_host *msh)
 	tasklet_schedule(&host->notify);
 }
 
+/* hardware reset */
 static int j38ms_reset(struct j38ms_host *host)
 {
 	int cnt;
@@ -700,6 +799,7 @@ static struct memstick_host *j38ms_alloc_host(struct j38ms *jm, int cnt)
 		return NULL;
 
 	host = memstick_priv(msh);
+	host->msh = msh;
 	host->chip = jm;
 	host->addr = ioremap(pci_resource_start(jm->pdev, cnt),
 			     pci_resource_len(jm->pdev, cnt));
drivers/memstick/host/jmb38x_ms.h +1 -0
index 44e1fc1..35b8bca 100644
@@ -144,6 +144,7 @@
 
 struct j38ms_host {
 	struct j38ms            *chip;
+	struct memstick_host    *msh;
 	void __iomem            *addr;
 	spinlock_t              lock;
 	struct tasklet_struct   notify;
Signature · 1 line
1.7.1
maintainer
#56 lore raw

Re: [PATCH 19/29] memstick: jmb38x_ms: add register read/write functions

Quoted 12 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 19/29] memstick: jmb38x_ms: add register read/write functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
All over the code it is a bit easier
to see the
register access with this patch. Also set/clear mask
helpers refactor code a bit, but the biggest reason
for this patch is to make it possible to trace register
read/writes with a flip of a module param.

Quoted 4 lines

Currently these functions are unused, but will be by later code

This looks like a case of:
1. You've run into a technical difficulty.
2. You used some temporary code to resolve and document it.
3. Now this temporary code is forever here to stay.

author maintainer
#57 lore raw

Re: [PATCH 19/29] memstick: jmb38x_ms: add register read/write functions

Quoted 17 lines · Alex Dubov
Quoted 15 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 19/29] memstick: jmb38x_ms: add register read/write functions
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
All over the code it is a bit easier
to see the
register access with this patch. Also set/clear mask
helpers refactor code a bit, but the biggest reason
for this patch is to make it possible to trace register
read/writes with a flip of a module param.

Currently these functions are unused, but will be by later code

Quoted 6 lines
Quoted 1 line

This looks like a case of:
1. You've run into a technical difficulty.
2. You used some temporary code to resolve and document it.
3. Now this temporary code is forever here to stay.

What? What you are accusing me of?
This is just an insult.

Having a simple way to trace register writes is always a good thing.

Also I have very similar code in ene_ir and r852. No complains.

Best regards,
Maxim Levitsky

author maintainer
#58 lore raw

PATCH 20/29 memstick: jmb38x_ms: rework PIO

In reply to Maxim Levitsky

Rewrite PIO code to be just simplier and shorter,
and comment not so obivous parts.

---
 drivers/memstick/host/jmb38x_ms.c |  283 +++++++++++++------------------------
 drivers/memstick/host/jmb38x_ms.h |   17 +--
 2 files changed, 103 insertions(+), 197 deletions(-)
drivers/memstick/host/jmb38x_ms.c +96 -185
index bcdb785..5af0a52 100644
@@ -17,6 +17,7 @@
 #include <linux/highmem.h>
 #include <linux/memstick.h>
 #include <linux/slab.h>
+#include <linux/scatterlist.h>
 #include "jmb38x_ms.h"
 
 static int no_dma;
@@ -103,39 +104,34 @@ static inline int j38ms_write_fifo_dword_pio(struct j38ms_host *host, u32 dword)
 static unsigned int j38ms_read_fifo_pio(struct j38ms_host *host,
 				unsigned char *buf, unsigned int length)
 {
-	unsigned int off = 0;
+	unsigned int orig_len = length;
+	unsigned char tmp_buf[4];
 
-	while (host->io_pos && length) {
-		buf[off++] = host->io_word[0] & 0xff;
-		host->io_word[0] >>= 8;
-		length--;
-		host->io_pos--;
+	/* Read bytes from last saved part */
+	if (host->pio_tmp_buf_len) {
+		int count = min(host->pio_tmp_buf_len, length);
+		memcpy(buf, host->pio_tmp_buf, count);
+		buf += count;
+		length -= count;
 	}
 
-	if (!length)
-		return off;
+	/* Read aligned data*/
+	for (; length >= 4 ; buf += 4, length -= 4)
+		if (j38ms_read_fifo_dword_pio(host, (u32 *)buf))
+			return orig_len - length;
 
-	while (!(STATUS_FIFO_EMPTY & readl(host->addr + STATUS))) {
-		if (length < 4)
-			break;
-		*(unsigned int *)(buf + off) = __raw_readl(host->addr + DATA);
-		length -= 4;
-		off += 4;
-	}
+	/* Read last 4 bytes, and
+			save unconsumed part of it to the pio_tmp_buf */
+	if (length && !j38ms_read_fifo_dword_pio(host, (u32 *)tmp_buf)) {
 
-	if (length
-	    && !(STATUS_FIFO_EMPTY & readl(host->addr + STATUS))) {
-		host->io_word[0] = readl(host->addr + DATA);
-		for (host->io_pos = 4; host->io_pos; --host->io_pos) {
-			buf[off++] = host->io_word[0] & 0xff;
-			host->io_word[0] >>= 8;
-			length--;
-			if (!length)
-				break;
-		}
+		host->pio_tmp_buf_len = 4 - length;
+		memcpy(buf, tmp_buf, length);
+		memcpy(host->pio_tmp_buf,
+				tmp_buf + length, host->pio_tmp_buf_len);
+		length = 0;
 	}
 
-	return off;
+	return orig_len - length;
 }
 
 /* Write TPC data through normal PIO fifo */
@@ -143,175 +139,106 @@ static unsigned int j38ms_write_fifo_pio(struct j38ms_host *host,
 					 unsigned char *buf,
 					 unsigned int length)
 {
-	unsigned int off = 0;
-
-	if (host->io_pos) {
-		while (host->io_pos < 4 && length) {
-			host->io_word[0] |=  buf[off++] << (host->io_pos * 8);
-			host->io_pos++;
-			length--;
+	unsigned int orig_len = length;
+
+	/* Complete the last saved bytes*/
+	if (host->pio_tmp_buf_len) {
+		int count = min(4 - host->pio_tmp_buf_len, length);
+		memcpy(host->pio_tmp_buf + host->pio_tmp_buf_len, buf, count);
+		buf += count;
+		length -= count;
+
+		if (host->pio_tmp_buf_len == 4) {
+			if (j38ms_write_fifo_dword_pio(
+					host, *(u32 *)host->pio_tmp_buf))
+				return orig_len - length;
+			else
+				host->pio_tmp_buf_len = 0;
 		}
 	}
 
-	if (host->io_pos == 4
-	    && !(STATUS_FIFO_FULL & readl(host->addr + STATUS))) {
-		writel(host->io_word[0], host->addr + DATA);
-		host->io_pos = 0;
-		host->io_word[0] = 0;
-	} else if (host->io_pos) {
-		return off;
-	}
-
-	if (!length)
-		return off;
-
-	while (!(STATUS_FIFO_FULL & readl(host->addr + STATUS))) {
-		if (length < 4)
-			break;
-
-		__raw_writel(*(unsigned int *)(buf + off),
-			     host->addr + DATA);
-		length -= 4;
-		off += 4;
-	}
+	/* Write aligned data to hardware */
+	for (; length >= 4 ; length -= 4, buf += 4)
+		if (j38ms_write_fifo_dword_pio(host, *(u32 *)buf))
+			return orig_len - length;
 
-	switch (length) {
-	case 3:
-		host->io_word[0] |= buf[off + 2] << 16;
-		host->io_pos++;
-	case 2:
-		host->io_word[0] |= buf[off + 1] << 8;
-		host->io_pos++;
-	case 1:
-		host->io_word[0] |= buf[off];
-		host->io_pos++;
+	/* Save last 3-1 bytes to buffer, because we can't send them now*/
+	if (length) {
+		memset(host->pio_tmp_buf, 0, 4);
+		memcpy(host->pio_tmp_buf, buf, length);
+		host->pio_tmp_buf_len = length;
 	}
 
-	off += host->io_pos;
-
-	return off;
+	return orig_len - length;
 }
 
+
 /* Transfer data between current request and FIFO */
-static int j38ms_transfer_data(struct j38ms_host *host)
+static void j38ms_transfer_pio(struct j38ms_host *host)
 {
-	unsigned int length;
-	unsigned int off;
-	unsigned int t_size, p_cnt;
 	unsigned char *buf;
-	struct page *pg;
+	unsigned int len;
 	unsigned long flags = 0;
 
-	if (host->req->long_data) {
-		length = host->req->sg.length - host->block_pos;
-		off = host->req->sg.offset + host->block_pos;
-	} else {
-		length = host->req->data_len - host->block_pos;
-		off = 0;
-	}
+	if (host->req->long_data)
+		local_irq_save(flags);
 
-	while (length) {
-		unsigned int uninitialized_var(p_off);
+	dbg_v(host, "PIO: new transfer");
 
+	while (1) {
 		if (host->req->long_data) {
-			pg = nth_page(sg_page(&host->req->sg),
-				      off >> PAGE_SHIFT);
-			p_off = offset_in_page(off);
-			p_cnt = PAGE_SIZE - p_off;
-			p_cnt = min(p_cnt, length);
-
-			local_irq_save(flags);
-			buf = kmap_atomic(pg, KM_BIO_SRC_IRQ) + p_off;
+			if (!sg_miter_next(&host->pio_sg_iter))
+				break;
+
+			buf = host->pio_sg_iter.addr;
+			len = host->pio_sg_iter.length;
 		} else {
-			buf = host->req->data + host->block_pos;
-			p_cnt = host->req->data_len - host->block_pos;
+			buf = host->req->data + host->pio_offset;
+			len = host->req->data_len - host->pio_offset;
+
+			if (!len)
+				break;
 		}
 
-		if (host->req->data_dir == WRITE)
-			t_size = !(host->cmd_flags & REG_DATA)
-				 ? j38ms_write_fifo_pio(host, buf, p_cnt)
-				 : j38ms_write_tpc_inline(host, buf, p_cnt);
-		else
-			t_size = !(host->cmd_flags & REG_DATA)
-				 ? j38ms_read_fifo_pio(host, buf, p_cnt)
-				 : j38ms_read_tpc_inline(host, buf, p_cnt);
+		len = host->req->data_dir == WRITE ?
+			j38ms_write_fifo_pio(host, buf, len) :
+			j38ms_read_fifo_pio(host, buf, len);
 
-		if (host->req->long_data) {
-			kunmap_atomic(buf - p_off, KM_BIO_SRC_IRQ);
-			local_irq_restore(flags);
-		}
+		if (host->req->long_data)
+			host->pio_sg_iter.consumed = len;
+		else
+			host->pio_offset += len;
 
-		if (!t_size)
-			break;
-		host->block_pos += t_size;
-		length -= t_size;
-		off += t_size;
+		dbg(host, "PIO: transfered %d bytes", len);
+		if (!len)
+			goto exit;
 	}
 
-	if (!length && host->req->data_dir == WRITE) {
-		if (host->cmd_flags & REG_DATA) {
-			writel(host->io_word[0], host->addr + TPC_P0);
-			writel(host->io_word[1], host->addr + TPC_P1);
-		} else if (host->io_pos) {
-			writel(host->io_word[0], host->addr + DATA);
-		}
+	/* Write last non-complete dword of the data */
+	if (host->req->data_dir == WRITE && host->pio_tmp_buf_len) {
+		if (!j38ms_write_fifo_dword_pio(host,
+						*(u32 *)host->pio_tmp_buf))
+			host->pio_tmp_buf_len = 0;
+	}
+exit:
+	if (host->req->long_data) {
+		sg_miter_stop(&host->pio_sg_iter);
+		local_irq_restore(flags);
 	}
-
-	return length;
 }
 
 /* Read short TPC data (up to 8 bytes) via 2 special registers*/
-static unsigned int j38ms_read_tpc_inline(struct j38ms_host *host,
-					    unsigned char *buf,
-					    unsigned int length)
+static void j38ms_read_tpc_inline(struct j38ms_host *host)
 {
-	unsigned int off = 0;
-
-	while (host->io_pos > 4 && length) {
-		buf[off++] = host->io_word[0] & 0xff;
-		host->io_word[0] >>= 8;
-		length--;
-		host->io_pos--;
-	}
-
-	if (!length)
-		return off;
-
-	while (host->io_pos && length) {
-		buf[off++] = host->io_word[1] & 0xff;
-		host->io_word[1] >>= 8;
-		length--;
-		host->io_pos--;
-	}
-
-	return off;
+       *(u32 *)(host->req->data + 0) = j38ms_read_reg_raw(host, TPC_P0);
+       *(u32 *)(host->req->data + 4) = j38ms_read_reg_raw(host, TPC_P1);
 }
 
 /* Write short TPC data (up to 8 bytes) through 2 special registers */
-static unsigned int j38ms_write_tpc_inline(struct j38ms_host *host,
-					     unsigned char *buf,
-					     unsigned int length)
+static void j38ms_write_tpc_inline(struct j38ms_host *host)
 {
-	unsigned int off = 0;
-
-	while (host->io_pos < 4 && length) {
-		host->io_word[0] &= ~(0xff << (host->io_pos * 8));
-		host->io_word[0] |=  buf[off++] << (host->io_pos * 8);
-		host->io_pos++;
-		length--;
-	}
-
-	if (!length)
-		return off;
-
-	while (host->io_pos < 8 && length) {
-		host->io_word[1] &= ~(0xff << (host->io_pos * 8));
-		host->io_word[1] |=  buf[off++] << (host->io_pos * 8);
-		host->io_pos++;
-		length--;
-	}
-
-	return off;
+	j38ms_write_reg_raw(host, TPC_P0, *(u32 *)(host->req->data + 0));
+	j38ms_write_reg_raw(host, TPC_P1, *(u32 *)(host->req->data + 4));
 }
 
 /*
@@ -344,10 +271,6 @@ static int j38ms_execute_tpc(struct memstick_host *msh)
 	dev_dbg(&msh->dev, "hstatus %08x\n", readl(host->addr + STATUS));
 
 	host->cmd_flags = 0;
-	host->block_pos = 0;
-	host->io_pos = 0;
-	host->io_word[0] = 0;
-	host->io_word[1] = 0;
 
 	cmd = host->req->tpc << 16;
 	cmd |= TPC_DATA_SEL;
@@ -407,11 +330,8 @@ static int j38ms_execute_tpc(struct memstick_host *msh)
 		host->cmd_flags |= REG_DATA;
 		cmd |= data_len & 0xf;
 
-		if (host->req->data_dir == WRITE) {
-			j38ms_transfer_data(host);
-			writel(host->io_word[0], host->addr + TPC_P0);
-			writel(host->io_word[1], host->addr + TPC_P1);
-		}
+		if (host->req->data_dir == WRITE)
+			j38ms_write_tpc_inline(host);
 	}
 
 	mod_timer(&host->timer, jiffies + host->timeout_jiffies);
@@ -504,10 +424,10 @@ static irqreturn_t j38ms_isr(int irq, void *dev_id)
 			} else {
 				if (irq_status & (INT_STATUS_FIFO_RRDY
 						  | INT_STATUS_FIFO_WRDY))
-					j38ms_transfer_data(host);
+					j38ms_transfer_pio(host);
 
 				if (irq_status & INT_STATUS_EOTRAN) {
-					j38ms_transfer_data(host);
+					j38ms_transfer_pio(host);
 					host->cmd_flags |= FIFO_READY;
 				}
 			}
@@ -515,17 +435,8 @@ static irqreturn_t j38ms_isr(int irq, void *dev_id)
 			if (irq_status & INT_STATUS_EOTPC) {
 				host->cmd_flags |= CMD_READY;
 				if (host->cmd_flags & REG_DATA) {
-					if (host->req->data_dir == READ) {
-						host->io_word[0]
-							= readl(host->addr
-								+ TPC_P0);
-						host->io_word[1]
-							= readl(host->addr
-								+ TPC_P1);
-						host->io_pos = 8;
-
-						j38ms_transfer_data(host);
-					}
+					if (host->req->data_dir == READ)
+						j38ms_read_tpc_inline(host);
 					host->cmd_flags |= FIFO_READY;
 				}
 			}
drivers/memstick/host/jmb38x_ms.h +6 -11
index 35b8bca..d7dffb6 100644
@@ -151,13 +151,16 @@ struct j38ms_host {
 	int                     id;
 	char                    host_id[32];
 	int                     irq;
-	unsigned int            block_pos;
 	unsigned long           timeout_jiffies;
 	struct timer_list       timer;
 	struct memstick_request *req;
 	unsigned char           cmd_flags;
-	unsigned char           io_pos;
-	unsigned int            io_word[2];
+
+	/* PIO state */
+	struct sg_mapping_iter  pio_sg_iter;
+	unsigned char		pio_offset;
+	unsigned char           pio_tmp_buf[4];
+	unsigned int            pio_tmp_buf_len;
 };
 
 struct j38ms {
@@ -187,11 +190,3 @@ enum {
 #define dbg(host, format, ...)		__dbg(host, 1, format, ## __VA_ARGS__)
 #define dbg_v(host, format, ...)	__dbg(host, 2, format, ## __VA_ARGS__)
 #define dbg_reg(host, format, ...)	__dbg(host, 3, format, ## __VA_ARGS__)
-
-static unsigned int j38ms_read_tpc_inline(struct j38ms_host *host,
-					    unsigned char *buf,
-					    unsigned int length);
-
-static unsigned int j38ms_write_tpc_inline(struct j38ms_host *host,
-					     unsigned char *buf,
-					     unsigned int length);
Signature · 1 line
1.7.1
maintainer
#59 lore raw

Re: [PATCH 20/29] memstick: jmb38x_ms: rework PIO

Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 20/29] memstick: jmb38x_ms: rework PIO
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Rewrite PIO code to be just simplier
and shorter,
and comment not so obivous parts.

---

Yet, you are fixing something that was not broken before.

author maintainer
#60 lore raw

Re: [PATCH 20/29] memstick: jmb38x_ms: rework PIO

Quoted 12 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 20/29] memstick: jmb38x_ms: rework PIO
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Rewrite PIO code to be just simplier
and shorter,
and comment not so obivous parts.

Quoted 4 lines
Quoted 2 lines

---

Yet, you are fixing something that was not broken before.

A code that is hard to read is broken even if it works, because its very easy for anyone to break it accidentally.
Anybody disagree (except you)?

Best regards,
Maxim Levitsky

author maintainer
#61 lore raw

PATCH 21/29 memstick: jmb38x_ms: rework TPC execution

In reply to Maxim Levitsky

Code rewritten to make it simplier.
A lot of debug output is added to help
diagnose bugs.

No major functional changes

---
 drivers/memstick/host/jmb38x_ms.c |  199 +++++++++++++++++++++----------------
 drivers/memstick/host/jmb38x_ms.h |    3 +-
 2 files changed, 114 insertions(+), 88 deletions(-)
drivers/memstick/host/jmb38x_ms.c +112 -87
index 5af0a52..d15118a 100644
@@ -254,94 +254,121 @@ static void j38ms_write_tpc_inline(struct j38ms_host *host)
  *	PIO _reads_ must be aligned. Writes can be not aligned
  *
  */
-static int j38ms_execute_tpc(struct memstick_host *msh)
+
+static int j38ms_execute_tpc(struct j38ms_host *host)
 {
-	struct j38ms_host *host = memstick_priv(msh);
-	unsigned char *data;
-	unsigned int data_len, cmd, t_val;
+	u32 cmd = 0, t_val;
+	unsigned int data_len = host->req->long_data ?
+		host->req->sg.length : host->req->data_len;
+	bool is_read = host->req->data_dir == READ;
+
+	if (!(j38ms_read_reg(host, STATUS) & STATUS_HAS_MEDIA)) {
+		dbg(host, "IO: card removed, refusing to send TPC");
+		host->req->error = -ENODEV;
+		return host->req->error;
+	}
 
-	if (!(STATUS_HAS_MEDIA & readl(host->addr + STATUS))) {
-		dev_dbg(&msh->dev, "no media status\n");
-		host->req->error = -ETIME;
+	if (data_len > BLOCK_SIZE_MASK) {
+		dbg(host, "IO: too long TPC (len: %d)", data_len);
+		host->req->error = -ENOSYS;
 		return host->req->error;
 	}
 
-	dev_dbg(&msh->dev, "control %08x\n", readl(host->addr + HOST_CONTROL));
-	dev_dbg(&msh->dev, "status %08x\n", readl(host->addr + INT_STATUS));
-	dev_dbg(&msh->dev, "hstatus %08x\n", readl(host->addr + STATUS));
+	dbg(host, "IO: Start execution of %s",
+		memstick_debug_get_tpc_name(host->req->tpc));
+
+
+	dbg_v(host, "host control: %08x", j38ms_read_reg(host, HOST_CONTROL));
+	dbg_v(host, "int status: %08x", j38ms_read_reg(host, INT_STATUS));
+	dbg_v(host, "card status: %08x", j38ms_read_reg(host, STATUS));
 
+	host->req->error = 0;
 	host->cmd_flags = 0;
 
 	cmd = host->req->tpc << 16;
-	cmd |= TPC_DATA_SEL;
-
-	if (host->req->data_dir == READ)
+	if (is_read)
 		cmd |= TPC_DIR;
-	if (host->req->need_card_int)
-		cmd |= TPC_WAIT_INT;
-
-	data = host->req->data;
-
-	if (!no_dma)
-		host->cmd_flags |= DMA_DATA;
 
-	if (host->req->long_data) {
-		data_len = host->req->sg.length;
-	} else {
-		data_len = host->req->data_len;
-		host->cmd_flags &= ~DMA_DATA;
+	if (host->req->need_card_int) {
+		dbg_v(host, "IO: Will wait for card interrupt");
+		cmd |= TPC_WAIT_INT;
+		/* No, the TPC_GET_INT doesn't work.... */
 	}
 
-	if (data_len <= 8) {
-		cmd &= ~(TPC_DATA_SEL | 0xf);
+	/* Special case for short TPCs */
+	if (!host->req->long_data && data_len <= 8) {
+		dbg(host, "IO: Using 8 byte register window");
 		host->cmd_flags |= REG_DATA;
 		cmd |= data_len & 0xf;
-		host->cmd_flags &= ~DMA_DATA;
+
+		if (!is_read)
+			j38ms_write_tpc_inline(host);
+		goto exec;
 	}
 
-	if (host->cmd_flags & DMA_DATA) {
-		if (1 != pci_map_sg(host->chip->pdev, &host->req->sg, 1,
-				    host->req->data_dir == READ
-				    ? PCI_DMA_FROMDEVICE
-				    : PCI_DMA_TODEVICE)) {
+	/* Otherwise use internal fifo*/
+	cmd |= TPC_DATA_SEL;
+
+	if (data_len & 0x03) {
+		dbg(host, "Hardware doesn't support not-aligned len TPCs!");
+		host->req->error = -ENOSYS;
+		return host->req->error;
+	}
+
+	/* DMA */
+	if (!no_dma && host->req->long_data) {
+
+		dbg(host, "IO: Using DMA");
+		host->cmd_flags |= DMA_DATA;
+
+		if (pci_map_sg(host->chip->pdev,
+			&host->req->sg, 1, is_read
+			? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE) != 1) {
+
+			dbg(host, "IO: DMA map failed");
 			host->req->error = -ENOMEM;
 			return host->req->error;
 		}
-		data_len = sg_dma_len(&host->req->sg);
-		writel(sg_dma_address(&host->req->sg),
-		       host->addr + DMA_ADDRESS);
-		writel(((1 << 16) & BLOCK_COUNT_MASK)
-		       | (data_len & BLOCK_SIZE_MASK),
-		       host->addr + BLOCK);
-		writel(DMA_CONTROL_ENABLE, host->addr + DMA_CONTROL);
-	} else if (!(host->cmd_flags & REG_DATA)) {
-		writel(((1 << 16) & BLOCK_COUNT_MASK)
-		       | (data_len & BLOCK_SIZE_MASK),
-		       host->addr + BLOCK);
-			t_val = readl(host->addr + INT_STATUS_ENABLE);
-			t_val |= host->req->data_dir == READ
-				 ? INT_STATUS_FIFO_RRDY
-				 : INT_STATUS_FIFO_WRDY;
-
-			writel(t_val, host->addr + INT_STATUS_ENABLE);
-			writel(t_val, host->addr + INT_SIGNAL_ENABLE);
+
+		/* We really shouldn't pretend we support that case */
+		if (sg_dma_len(&host->req->sg) != data_len) {
+			dbg(host, "IO: DMA len mismatch");
+			host->req->error = -EFAULT;
+			return host->req->error;
+		}
+
+		j38ms_write_reg(host, BLOCK, data_len | BLOCK_COUNT_1BLOCK);
+		j38ms_write_reg(host, DMA_ADDRESS,
+					sg_dma_address(&host->req->sg));
+		j38ms_write_reg(host, DMA_CONTROL, DMA_CONTROL_ENABLE);
+	/* PIO */
 	} else {
-		cmd &= ~(TPC_DATA_SEL | 0xf);
-		host->cmd_flags |= REG_DATA;
-		cmd |= data_len & 0xf;
 
-		if (host->req->data_dir == WRITE)
-			j38ms_write_tpc_inline(host);
-	}
+		dbg(host, "IO: Using PIO");
+		host->cmd_flags |= PIO_DATA;
 
-	mod_timer(&host->timer, jiffies + host->timeout_jiffies);
-	writel(HOST_CONTROL_LED | readl(host->addr + HOST_CONTROL),
-	       host->addr + HOST_CONTROL);
-	host->req->error = 0;
+		host->pio_offset = 0;
+		host->pio_tmp_buf_len = 0;
+		memset(host->pio_tmp_buf, 0, 4);
 
-	writel(cmd, host->addr + TPC);
-	dev_dbg(&msh->dev, "executing TPC %08x, len %x\n", cmd, data_len);
+		if (host->req->long_data)
+			sg_miter_start(&host->pio_sg_iter,
+				&host->req->sg, 1, SG_MITER_ATOMIC |
+				(is_read ? SG_MITER_FROM_SG : SG_MITER_TO_SG));
+
+		/* Enable FIFO empty interrupts */
+		t_val = is_read ? INT_STATUS_FIFO_RRDY : INT_STATUS_FIFO_WRDY;
 
+		j38ms_write_reg(host, BLOCK, data_len | BLOCK_COUNT_1BLOCK);
+		j38ms_set_reg_mask(host, INT_SIGNAL_ENABLE, t_val);
+		j38ms_set_reg_mask(host, INT_STATUS_ENABLE, t_val);
+	}
+exec:
+	mod_timer(&host->timer, jiffies + host->timeout_jiffies);
+
+	/* Let the TPC fly... */
+	j38ms_write_reg(host, TPC, cmd);
+	j38ms_set_reg_mask(host, HOST_CONTROL, HOST_CONTROL_LED);
 	return 0;
 }
 
@@ -349,44 +376,42 @@ static int j38ms_execute_tpc(struct memstick_host *msh)
 static void j38ms_complete_tpc(struct memstick_host *msh, int last)
 {
 	struct j38ms_host *host = memstick_priv(msh);
-	unsigned int t_val = 0;
 	int rc;
-
 	del_timer(&host->timer);
 
-	dev_dbg(&msh->dev, "c control %08x\n",
-		readl(host->addr + HOST_CONTROL));
-	dev_dbg(&msh->dev, "c status %08x\n",
-		readl(host->addr + INT_STATUS));
-	dev_dbg(&msh->dev, "c hstatus %08x\n", readl(host->addr + STATUS));
+	dbg(host, "IO: TPC complete (error : %d)", host->req->error);
 
-	host->req->int_reg = readl(host->addr + STATUS) & 0xff;
+	j38ms_write_reg(host, BLOCK, 0);
+	j38ms_write_reg(host, DMA_CONTROL, 0);
 
-	writel(0, host->addr + BLOCK);
-	writel(0, host->addr + DMA_CONTROL);
+	dbg_v(host, "host control: %08x", j38ms_read_reg(host, HOST_CONTROL));
+	dbg_v(host, "int status: %08x", j38ms_read_reg(host, INT_STATUS));
+	dbg_v(host, "card status: %08x", j38ms_read_reg(host, STATUS));
+
+	if (host->req->need_card_int)
+		host->req->int_reg = j38ms_read_reg(host, STATUS) & 0xFF;
 
 	if (host->cmd_flags & DMA_DATA) {
 		pci_unmap_sg(host->chip->pdev, &host->req->sg, 1,
-			     host->req->data_dir == READ
-			     ? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
-	} else {
-		t_val = readl(host->addr + INT_STATUS_ENABLE);
-		if (host->req->data_dir == READ)
-			t_val &= ~INT_STATUS_FIFO_RRDY;
-		else
-			t_val &= ~INT_STATUS_FIFO_WRDY;
+			host->req->data_dir == READ
+			? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
 
-		writel(t_val, host->addr + INT_STATUS_ENABLE);
-		writel(t_val, host->addr + INT_SIGNAL_ENABLE);
+	} else if (host->cmd_flags & PIO_DATA) {
+		u32 t_val = INT_STATUS_FIFO_RRDY | INT_STATUS_FIFO_WRDY;
+
+		/* This is not known well */
+		j38ms_clear_reg_mask(host, INT_STATUS_ENABLE, t_val);
+
+		/* This disables the IRQ to host, really */
+		j38ms_clear_reg_mask(host, INT_SIGNAL_ENABLE, t_val);
 	}
 
-	writel((~HOST_CONTROL_LED) & readl(host->addr + HOST_CONTROL),
-	       host->addr + HOST_CONTROL);
+	j38ms_clear_reg_mask(host, HOST_CONTROL, HOST_CONTROL_LED);
 
 	if (!last) {
 		do {
 			rc = memstick_next_req(msh, &host->req);
-		} while (!rc && j38ms_execute_tpc(msh));
+		} while (!rc && j38ms_execute_tpc(host));
 	} else {
 		do {
 			rc = memstick_next_req(msh, &host->req);
@@ -488,7 +513,7 @@ static void j38ms_submit_tasklet(unsigned long data)
 		do {
 			rc = memstick_next_req(msh, &host->req);
 			dev_dbg(&host->chip->pdev->dev, "tasklet req %d\n", rc);
-		} while (!rc && j38ms_execute_tpc(msh));
+		} while (!rc && j38ms_execute_tpc(host));
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 }
drivers/memstick/host/jmb38x_ms.h +2 -1
index d7dffb6..429ed49 100644
@@ -173,7 +173,8 @@ enum {
 	CMD_READY    = 0x01,
 	FIFO_READY   = 0x02,
 	REG_DATA     = 0x04,
-	DMA_DATA     = 0x08
+	DMA_DATA     = 0x08,
+	PIO_DATA     = 0x10
 };
 
 
Signature · 1 line
1.7.1
maintainer
#62 lore raw

Re: [PATCH 21/29] memstick: jmb38x_ms: rework TPC execution

Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 21/29] memstick: jmb38x_ms: rework TPC execution
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Code rewritten to make it simplier.
A lot of debug output is added to help
diagnose bugs.

Quoted 3 lines

No major functional changes

Was not broken beforehand.

author maintainer
#63 lore raw

Re: [PATCH 21/29] memstick: jmb38x_ms: rework TPC execution

Quoted 12 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 21/29] memstick: jmb38x_ms: rework TPC execution
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Code rewritten to make it simplier.
A lot of debug output is added to help
diagnose bugs.

Quoted 5 lines
Quoted 3 lines

No major functional changes

Was not broken beforehand.

Yet is was.
Best regards,
Maxim Levitsky

author maintainer
#64 lore raw

PATCH 22/29 memstick: jmb38x_ms: rework ISR

In reply to Maxim Levitsky

New ISR is simplier.
Also it only services the hardware when we expect to thus it workarounds the stuck write ready bit hw bug.

---
 drivers/memstick/host/jmb38x_ms.c |   90 +++++++++++++++++++++---------------
 1 files changed, 52 insertions(+), 38 deletions(-)
drivers/memstick/host/jmb38x_ms.c +52 -38
index d15118a..6b87e23 100644
@@ -426,60 +426,74 @@ static irqreturn_t j38ms_isr(int irq, void *dev_id)
 {
 	struct memstick_host *msh = dev_id;
 	struct j38ms_host *host = memstick_priv(msh);
-	unsigned int irq_status;
+	u32 irq_status;
 
 	spin_lock(&host->lock);
-	irq_status = readl(host->addr + INT_STATUS);
-	dev_dbg(&host->chip->pdev->dev, "irq_status = %08x\n", irq_status);
+	irq_status = j38ms_read_reg(host, INT_STATUS);
+
 	if (irq_status == 0 || irq_status == (~0)) {
 		spin_unlock(&host->lock);
 		return IRQ_NONE;
 	}
 
-	if (host->req) {
-		if (irq_status & INT_STATUS_ANY_ERR) {
-			if (irq_status & INT_STATUS_CRC_ERR)
-				host->req->error = -EILSEQ;
-			else
-				host->req->error = -ETIME;
-		} else {
-			if (host->cmd_flags & DMA_DATA) {
-				if (irq_status & INT_STATUS_EOTRAN)
-					host->cmd_flags |= FIFO_READY;
-			} else {
-				if (irq_status & (INT_STATUS_FIFO_RRDY
-						  | INT_STATUS_FIFO_WRDY))
-					j38ms_transfer_pio(host);
-
-				if (irq_status & INT_STATUS_EOTRAN) {
-					j38ms_transfer_pio(host);
-					host->cmd_flags |= FIFO_READY;
-				}
-			}
-
-			if (irq_status & INT_STATUS_EOTPC) {
-				host->cmd_flags |= CMD_READY;
-				if (host->cmd_flags & REG_DATA) {
-					if (host->req->data_dir == READ)
-						j38ms_read_tpc_inline(host);
-					host->cmd_flags |= FIFO_READY;
-				}
-			}
+	dbg(host, "IRQ: status: %08x", irq_status);
+
+	if (irq_status & INT_STATUS_ANY_ERR)
+		dbg(host, "IRQ: error");
+
+	if (irq_status & INT_STATUS_FIFO_RRDY)
+		dbg(host, "IRQ: FIFO is now ready for reading");
+
+	if (irq_status & INT_STATUS_FIFO_WRDY)
+		dbg(host, "IRQ: FIFO is now ready for writing");
+
+	if (irq_status & INT_STATUS_EOTRAN)
+		dbg(host, "IRQ: FIFO IO tranfer done");
+
+	if (irq_status & INT_STATUS_EOTPC)
+		dbg(host, "IRQ: TPC complete");
+
+	if (!host->req)
+		goto out;
+
+	/* Errors */
+	if (irq_status & INT_STATUS_ANY_ERR) {
+		host->req->error =
+			(irq_status & INT_STATUS_CRC_ERR) ? -EILSEQ : -EIO;
+		goto out;
+	}
+
+	/* End of TPC interrupt */
+	if (irq_status & INT_STATUS_EOTPC) {
+		host->cmd_flags |= CMD_READY;
+
+		if (host->cmd_flags & REG_DATA) {
+			if (host->req->data_dir == READ)
+				j38ms_read_tpc_inline(host);
+			host->cmd_flags |= FIFO_READY;
 		}
 	}
 
+	/* Fifo handling */
+	if (irq_status & INT_STATUS_EOTRAN)
+		host->cmd_flags |= FIFO_READY;
+	else if (irq_status & (INT_STATUS_FIFO_RRDY | INT_STATUS_FIFO_WRDY))
+		if (host->cmd_flags & PIO_DATA)
+			j38ms_transfer_pio(host);
+
+out:
 	if (irq_status & (INT_STATUS_MEDIA_IN | INT_STATUS_MEDIA_OUT)) {
-		dev_dbg(&host->chip->pdev->dev, "media changed\n");
+		dbg(host, "IRQ: media changed");
 		memstick_detect_change(msh);
 	}
 
-	writel(irq_status, host->addr + INT_STATUS);
+	/* Yes, interrupt status is cleared by setting the bits as usual */
+	j38ms_write_reg(host, INT_STATUS, irq_status);
 
-	if (host->req
-	    && (((host->cmd_flags & CMD_READY)
-		 && (host->cmd_flags & FIFO_READY))
-		|| host->req->error))
+	if (host->req && (((host->cmd_flags & CMD_READY)
+		&& (host->cmd_flags & FIFO_READY)) || host->req->error)) {
 		j38ms_complete_tpc(msh, 0);
+	}
 
 	spin_unlock(&host->lock);
 	return IRQ_HANDLED;
Signature · 1 line
1.7.1
maintainer
#65 lore raw

Re: [PATCH 22/29] memstick: jmb38x_ms: rework ISR

Quoted 11 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 22/29] memstick: jmb38x_ms: rework ISR
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
New ISR is simplier.
Also it only services the hardware when we expect to
thus it workarounds the stuck write ready bit hw bug.

---

Probably it is.

author maintainer
#66 lore raw

Re: [PATCH 22/29] memstick: jmb38x_ms: rework ISR

Quoted 12 lines · Alex Dubov
Quoted 9 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 22/29] memstick: jmb38x_ms: rework ISR
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
New ISR is simplier.
Also it only services the hardware when we expect to
thus it workarounds the stuck write ready bit hw bug.

Quoted 4 lines
Quoted 2 lines

---

Probably it is.

I am very happy to see you agree at least on this one.

Best regards,
Maxim Levitsky

author maintainer
#67 lore raw

PATCH 23/29 memstick: jmb38x_ms: use DMA for all TPCs with len greater that 8 by default

In reply to Maxim Levitsky

This is to workaround a wierd hardware bug:

If PIO write is used, and then after it DMA write is used, DMA engine stops doing writes.
That condition even persists after device reset.

To be maxumum safe, we do dma to a scratch page
and memcpy from/to it.

Besides this change should just improve performance.

---
 drivers/memstick/host/jmb38x_ms.c |   65 ++++++++++++++++++++++++++----------
 drivers/memstick/host/jmb38x_ms.h |    5 +++
 2 files changed, 52 insertions(+), 18 deletions(-)
drivers/memstick/host/jmb38x_ms.c +47 -18
index 6b87e23..77e4971 100644
@@ -261,6 +261,7 @@ static int j38ms_execute_tpc(struct j38ms_host *host)
 	unsigned int data_len = host->req->long_data ?
 		host->req->sg.length : host->req->data_len;
 	bool is_read = host->req->data_dir == READ;
+	dma_addr_t dma_address;
 
 	if (!(j38ms_read_reg(host, STATUS) & STATUS_HAS_MEDIA)) {
 		dbg(host, "IO: card removed, refusing to send TPC");
@@ -316,30 +317,40 @@ static int j38ms_execute_tpc(struct j38ms_host *host)
 	}
 
 	/* DMA */
-	if (!no_dma && host->req->long_data) {
+	if (!no_dma) {
 
 		dbg(host, "IO: Using DMA");
 		host->cmd_flags |= DMA_DATA;
 
-		if (pci_map_sg(host->chip->pdev,
-			&host->req->sg, 1, is_read
-			? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE) != 1) {
+		if (host->req->long_data) {
 
-			dbg(host, "IO: DMA map failed");
-			host->req->error = -ENOMEM;
-			return host->req->error;
-		}
+			if (pci_map_sg(host->chip->pdev,
+				&host->req->sg, 1, is_read
+				? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE) != 1) {
+
+				dbg(host, "IO: DMA map failed");
+				host->req->error = -ENOMEM;
+				return host->req->error;
+			}
+
+			/* We really shouldn't pretend we support that case */
+			if (sg_dma_len(&host->req->sg) != data_len) {
+				dbg(host, "IO: DMA len mismatch");
+				host->req->error = -EFAULT;
+				return host->req->error;
+			}
 
-		/* We really shouldn't pretend we support that case */
-		if (sg_dma_len(&host->req->sg) != data_len) {
-			dbg(host, "IO: DMA len mismatch");
-			host->req->error = -EFAULT;
-			return host->req->error;
+			dma_address = sg_dma_address(&host->req->sg);
+
+		} else {
+			if (!is_read)
+				memcpy(host->dma_bounce_page,
+					host->req->data, data_len);
+			dma_address = host->dma_bus_address;
 		}
 
 		j38ms_write_reg(host, BLOCK, data_len | BLOCK_COUNT_1BLOCK);
-		j38ms_write_reg(host, DMA_ADDRESS,
-					sg_dma_address(&host->req->sg));
+		j38ms_write_reg(host, DMA_ADDRESS, dma_address);
 		j38ms_write_reg(host, DMA_CONTROL, DMA_CONTROL_ENABLE);
 	/* PIO */
 	} else {
@@ -392,9 +403,13 @@ static void j38ms_complete_tpc(struct memstick_host *msh, int last)
 		host->req->int_reg = j38ms_read_reg(host, STATUS) & 0xFF;
 
 	if (host->cmd_flags & DMA_DATA) {
-		pci_unmap_sg(host->chip->pdev, &host->req->sg, 1,
-			host->req->data_dir == READ
-			? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
+		if (host->req->long_data)
+			pci_unmap_sg(host->chip->pdev, &host->req->sg, 1,
+				host->req->data_dir == READ
+				? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
+		else if (host->req->data_dir == READ)
+			memcpy(host->req->data,
+				host->dma_bounce_page, host->req->data_len);
 
 	} else if (host->cmd_flags & PIO_DATA) {
 		u32 t_val = INT_STATUS_FIFO_RRDY | INT_STATUS_FIFO_WRDY;
@@ -771,12 +786,23 @@ static struct memstick_host *j38ms_alloc_host(struct j38ms *jm, int cnt)
 
 	setup_timer(&host->timer, j38ms_irq_timeout, (unsigned long)msh);
 
+	host->dma_bounce_page = pci_alloc_consistent(
+				jm->pdev, PAGE_SIZE, &host->dma_bus_address);
+
+	if (!host->dma_bounce_page)
+		goto err_out_free;
+
 	if (!request_irq(host->irq, j38ms_isr, IRQF_SHARED, host->host_id,
 			 msh))
 		return msh;
 
 	iounmap(host->addr);
 err_out_free:
+
+	if (host->dma_bounce_page)
+		pci_free_consistent(jm->pdev, PAGE_SIZE,
+			host->dma_bounce_page, host->dma_bus_address);
+
 	kfree(msh);
 	return NULL;
 }
@@ -787,6 +813,9 @@ static void j38ms_free_host(struct memstick_host *msh)
 
 	free_irq(host->irq, msh);
 	iounmap(host->addr);
+
+	pci_free_consistent(host->chip->pdev, PAGE_SIZE,
+		host->dma_bounce_page, host->dma_bus_address);
 	memstick_free_host(msh);
 }
 
drivers/memstick/host/jmb38x_ms.h +5 -0
index 429ed49..5599803 100644
@@ -161,6 +161,11 @@ struct j38ms_host {
 	unsigned char		pio_offset;
 	unsigned char           pio_tmp_buf[4];
 	unsigned int            pio_tmp_buf_len;
+
+	/* DMA bounce buffer */
+	void			*dma_bounce_page;
+	dma_addr_t		dma_bus_address;
+
 };
 
 struct j38ms {
Signature · 1 line
1.7.1
maintainer
#68 lore raw

Re: [PATCH 23/29] memstick: jmb38x_ms: use DMA for all TPCs with len greater that 8 by default

Quoted 13 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 23/29] memstick: jmb38x_ms: use DMA for all TPCs with len greater that 8 by default
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This is to workaround a wierd
hardware bug:

If PIO write is used, and then after it DMA write is used, DMA
engine stops doing writes.
That condition even persists after device reset.

Quoted 7 lines

To be maxumum safe, we do dma to a scratch page
and memcpy from/to it.

Besides this change should just improve performance.

---

I have not noticed this one before, and for all I know the driver was tested at Jmicron.
Can you explain the issue a bit more?

author maintainer
#69 lore raw

Re: [PATCH 23/29] memstick: jmb38x_ms: use DMA for all TPCs with len greater that 8 by default

Quoted 18 lines · Alex Dubov
Quoted 16 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 23/29] memstick: jmb38x_ms: use DMA for all TPCs with len greater that 8 by default
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
This is to workaround a wierd
hardware bug:

If PIO write is used, and then after it DMA write is used, DMA
engine stops doing writes.
That condition even persists after device reset.

To be maxumum safe, we do dma to a scratch page
and memcpy from/to it.

Quoted 8 lines
Quoted 4 lines

Besides this change should just improve performance.

---

I have not noticed this one before, and for all I know the driver was tested at Jmicron.
Can you explain the issue a bit more?

Because you didn't test MS standard, or always wrote OOB and param by seperate TPCs.

You really don't read my mail.

<quote>
***Appendix***

Jmicron hardware bugs (the novel):

#1: FIFO write ready bit in INT status register is stuck to 1.
It is stuck forever as soon as fifo
is used for writing even once.
Therefore if interrupt is shared (and here it is), its easy to 'service' the device while it doesn't need any service

#2: Its not possible to stuff the FIFO before TPC transfer.
One really have to wait for write ready interrupt, even though the
write ready status is stuck.

#3: TPCs with non 4 aligned length woes:
Facts:

* non 4 aligned DMA write hangs the system hard, maybe on bus level.

* PIO read succedes but controller truncates the data stored in the
FIFO to closest 4 byte boundary.
That is if you read 26 bytes, it will save 24 bytes in the FIFO

* TPC_P0, TPC_P1 not aligned transfters work just fine despite a
statement in the datasheet
(only mention of this problem)

#4: As soon as write PIO is used, then later write DMA fails.
Facts:

* This is triggered only by PIO write of registers (only happens in ms_block.c when it writes param + oob. Thats why
mspro_blk isn't affected)
Doing short DMA writes is a nice workaround.

* Doing PIO writes in h_msb_read_page don't cause the problem. Therefore the bug causing sequence should be similiar to
h_msb_write_block:

1. PIO write of param + extra (10 bytes) or even padded to 12 or
16 bytes
2. inline write (TPC_P0) of MS_CMD_BLOCK_WRITE + wait for int
3. read of INT register via STATUS
3. DMA write of MS_TPC_WRITE_LONG_DATA
4. DMA write of MS_TPC_WRITE_LONG_DATA ---------timeout-----------

* In fact first DMA write succedes, but next one fails, and so do all
following writes

* The problem persits till reboot, and shows up even if PIO isn't
used again.
Other way to "fix" it, is to put device in D3 and back to D0

* Serial/parallel mode don't affect anything.

After bug reproduction:

* DMA writes stop working completely, therefore mspro_blk looses
writes as well

* PIO still works just fine. Its possible just to load the driver
without dma support, and it works correctly.

* DMA reads work just fine.

#5: Auto_Get_INT feature just doesn't work.
Datasheet says that intreg is placed to TPC_P0, but that doesn't
happen....
</quote>

author maintainer
#70 lore raw

PATCH 24/29 memstick: jmb38x_ms: rework processing of the TPC one after another.

In reply to Maxim Levitsky

Lift some common code.
Also make sure new TPC is always exacuted from a tasklet. While this decreases IO speed a bit, this makes sure we won't have large latency.

---
 drivers/memstick/host/jmb38x_ms.c |   74 ++++++++++++++++++-------------------
 drivers/memstick/host/jmb38x_ms.h |    5 ++-
 2 files changed, 40 insertions(+), 39 deletions(-)
drivers/memstick/host/jmb38x_ms.c +36 -38
index 77e4971..16d022e 100644
@@ -263,6 +263,11 @@ static int j38ms_execute_tpc(struct j38ms_host *host)
 	bool is_read = host->req->data_dir == READ;
 	dma_addr_t dma_address;
 
+	if (host->dead) {
+		host->req->error = -ETIME;
+		return 0;
+	}
+
 	if (!(j38ms_read_reg(host, STATUS) & STATUS_HAS_MEDIA)) {
 		dbg(host, "IO: card removed, refusing to send TPC");
 		host->req->error = -ENODEV;
@@ -384,10 +389,9 @@ exec:
 }
 
 /* Cleanups execution of current TPC */
-static void j38ms_complete_tpc(struct memstick_host *msh, int last)
+static void j38ms_complete_tpc(struct memstick_host *msh)
 {
 	struct j38ms_host *host = memstick_priv(msh);
-	int rc;
 	del_timer(&host->timer);
 
 	dbg(host, "IO: TPC complete (error : %d)", host->req->error);
@@ -422,18 +426,6 @@ static void j38ms_complete_tpc(struct memstick_host *msh, int last)
 	}
 
 	j38ms_clear_reg_mask(host, HOST_CONTROL, HOST_CONTROL_LED);
-
-	if (!last) {
-		do {
-			rc = memstick_next_req(msh, &host->req);
-		} while (!rc && j38ms_execute_tpc(host));
-	} else {
-		do {
-			rc = memstick_next_req(msh, &host->req);
-			if (!rc)
-				host->req->error = -ETIME;
-		} while (!rc);
-	}
 }
 
 /* Interrupt handler */
@@ -507,7 +499,8 @@ out:
 
 	if (host->req && (((host->cmd_flags & CMD_READY)
 		&& (host->cmd_flags & FIFO_READY)) || host->req->error)) {
-		j38ms_complete_tpc(msh, 0);
+		j38ms_complete_tpc(msh);
+		tasklet_schedule(&host->tasklet);
 	}
 
 	spin_unlock(&host->lock);
@@ -525,7 +518,8 @@ static void j38ms_irq_timeout(unsigned long data)
 	spin_lock_irqsave(&host->lock, flags);
 	if (host->req) {
 		host->req->error = -ETIME;
-		j38ms_complete_tpc(msh, 0);
+		j38ms_complete_tpc(msh);
+		tasklet_schedule(&host->tasklet);
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 }
@@ -535,30 +529,29 @@ static void j38ms_submit_tasklet(unsigned long data)
 	struct memstick_host *msh = (struct memstick_host *)data;
 	struct j38ms_host *host = memstick_priv(msh);
 	unsigned long flags;
-	int rc;
 
 	spin_lock_irqsave(&host->lock, flags);
-	if (!host->req) {
-		do {
-			rc = memstick_next_req(msh, &host->req);
-			dev_dbg(&host->chip->pdev->dev, "tasklet req %d\n", rc);
-		} while (!rc && j38ms_execute_tpc(host));
-	}
+	j38ms_next_request(host);
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void j38ms_dummy_submit(struct memstick_host *msh)
-{
-	return;
-}
-
 static void j38ms_submit_req(struct memstick_host *msh)
 {
 	struct j38ms_host *host = memstick_priv(msh);
 
-	tasklet_schedule(&host->notify);
+	if (!host->req)
+		tasklet_schedule(&host->tasklet);
 }
 
+/* Asks for next request from upper layer and starts its execution */
+static void j38ms_next_request(struct j38ms_host *host)
+{
+	while (!memstick_next_req(host->msh, &host->req))
+		if (!j38ms_execute_tpc(host))
+			return;
+}
+
+
 /* hardware reset */
 static int j38ms_reset(struct j38ms_host *host)
 {
@@ -747,7 +740,6 @@ static int j38ms_count_slots(struct pci_dev *pdev)
 
 		if (256 != pci_resource_len(pdev, cnt))
 			break;
-
 		++rc;
 	}
 	return rc;
@@ -816,6 +808,7 @@ static void j38ms_free_host(struct memstick_host *msh)
 
 	pci_free_consistent(host->chip->pdev, PAGE_SIZE,
 		host->dma_bounce_page, host->dma_bus_address);
+
 	memstick_free_host(msh);
 }
 
@@ -905,21 +898,26 @@ static void j38ms_remove(struct pci_dev *dev)
 
 		host = memstick_priv(jm->hosts[cnt]);
 
-		jm->hosts[cnt]->request = j38ms_dummy_submit;
-		tasklet_kill(&host->notify);
-		writel(0, host->addr + INT_SIGNAL_ENABLE);
-		writel(0, host->addr + INT_STATUS_ENABLE);
-		mmiowb();
-		dev_dbg(&jm->pdev->dev, "interrupts off\n");
+		tasklet_kill(&host->tasklet);
+
 		spin_lock_irqsave(&host->lock, flags);
+		host->dead = true;
+
+		j38ms_write_reg(host, INT_SIGNAL_ENABLE, 0);
+		j38ms_write_reg(host, INT_STATUS_ENABLE, 0);
+
+		mmiowb();
+		dbg(host, "interrupts off");
+
 		if (host->req) {
 			host->req->error = -ETIME;
-			j38ms_complete_tpc(jm->hosts[cnt], 1);
+			j38ms_complete_tpc(jm->hosts[cnt]);
 		}
+
 		spin_unlock_irqrestore(&host->lock, flags);
 
 		memstick_remove_host(jm->hosts[cnt]);
-		dev_dbg(&jm->pdev->dev, "host removed\n");
+		dbg(host, "host removed");
 
 		j38ms_free_host(jm->hosts[cnt]);
 	}
drivers/memstick/host/jmb38x_ms.h +4 -1
index 5599803..5d7ad18 100644
@@ -146,8 +146,9 @@ struct j38ms_host {
 	struct j38ms            *chip;
 	struct memstick_host    *msh;
 	void __iomem            *addr;
+	bool			dead;
 	spinlock_t              lock;
-	struct tasklet_struct   notify;
+	struct tasklet_struct   tasklet;
 	int                     id;
 	char                    host_id[32];
 	int                     irq;
@@ -196,3 +197,5 @@ enum {
 #define dbg(host, format, ...)		__dbg(host, 1, format, ## __VA_ARGS__)
 #define dbg_v(host, format, ...)	__dbg(host, 2, format, ## __VA_ARGS__)
 #define dbg_reg(host, format, ...)	__dbg(host, 3, format, ## __VA_ARGS__)
+
+static void j38ms_next_request(struct j38ms_host *host);
Signature · 1 line
1.7.1
maintainer
#71 lore raw

Re: [PATCH 24/29] memstick: jmb38x_ms: rework processing of the TPC one after another.

Quoted 10 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 24/29] memstick: jmb38x_ms: rework processing of the TPC one after another.
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Lift some common code.
Also make sure new TPC is always exacuted from a tasklet.
While this decreases IO speed a bit, this makes sure
we won't have large latency.

Quoted 2 lines

---

Probably a good idea.

author maintainer
#72 lore raw

PATCH 25/29 memstick: jmb38x_ms: pass j38ms_host to few functions instead of memstick_host

In reply to Maxim Levitsky

Just for consistency

---
 drivers/memstick/host/jmb38x_ms.c |   18 +++++++++---------
 1 files changed, 9 insertions(+), 9 deletions(-)
drivers/memstick/host/jmb38x_ms.c +9 -9
index 16d022e..725b485 100644
@@ -510,24 +510,24 @@ out:
 /* Timer that is executed in absense of the interrupt */
 static void j38ms_irq_timeout(unsigned long data)
 {
-	struct memstick_host *msh = (struct memstick_host *)data;
-	struct j38ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = (struct j38ms_host *)data;
 	unsigned long flags;
 
-	dev_dbg(&host->chip->pdev->dev, "abort\n");
+	dbg(host, "interrupt timeout");
+
 	spin_lock_irqsave(&host->lock, flags);
 	if (host->req) {
 		host->req->error = -ETIME;
-		j38ms_complete_tpc(msh);
+		j38ms_complete_tpc(host->msh);
 		tasklet_schedule(&host->tasklet);
 	}
+
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
 static void j38ms_submit_tasklet(unsigned long data)
 {
-	struct memstick_host *msh = (struct memstick_host *)data;
-	struct j38ms_host *host = memstick_priv(msh);
+	struct j38ms_host *host = (struct j38ms_host *)data;
 	unsigned long flags;
 
 	spin_lock_irqsave(&host->lock, flags);
@@ -768,15 +768,15 @@ static struct memstick_host *j38ms_alloc_host(struct j38ms *jm, int cnt)
 	snprintf(host->host_id, sizeof(host->host_id), DRIVER_NAME ":slot%d",
 		 host->id);
 	host->irq = jm->pdev->irq;
-	host->timeout_jiffies = msecs_to_jiffies(1000);
 
-	tasklet_init(&host->notify, j38ms_submit_tasklet, (unsigned long)msh);
 	msh->request = j38ms_submit_req;
 	msh->set_param = j38ms_set_param;
 
 	msh->caps = MEMSTICK_CAP_PAR4 | MEMSTICK_CAP_PAR8;
 
-	setup_timer(&host->timer, j38ms_irq_timeout, (unsigned long)msh);
+	host->timeout_jiffies = msecs_to_jiffies(1000);
+	setup_timer(&host->timer, j38ms_irq_timeout, (unsigned long)host);
+	tasklet_init(&host->tasklet, j38ms_submit_tasklet, (unsigned long)host);
 
 	host->dma_bounce_page = pci_alloc_consistent(
 				jm->pdev, PAGE_SIZE, &host->dma_bus_address);
Signature · 1 line
1.7.1
author maintainer
#73 lore raw

PATCH 26/29 memstick: jmb38x_ms: rework hardware setup/reset

In reply to Maxim Levitsky

Move the code into functions.
Reset clock on init - fixes serial mode

---
 drivers/memstick/host/jmb38x_ms.c |  205 +++++++++++++++++++------------------
 drivers/memstick/host/jmb38x_ms.h |   11 +-
 2 files changed, 108 insertions(+), 108 deletions(-)
drivers/memstick/host/jmb38x_ms.c +103 -102
index 725b485..86c003a 100644
@@ -551,131 +551,132 @@ static void j38ms_next_request(struct j38ms_host *host)
 			return;
 }
 
-
 /* hardware reset */
-static int j38ms_reset(struct j38ms_host *host)
+static int j38ms_reset(struct j38ms_host *host, u32 reset_bit)
 {
-	int cnt;
-
-	writel(HOST_CONTROL_RESET_REQ | HOST_CONTROL_CLOCK_EN
-	       | readl(host->addr + HOST_CONTROL),
-	       host->addr + HOST_CONTROL);
-	mmiowb();
-
-	for (cnt = 0; cnt < 20; ++cnt) {
-		if (!(HOST_CONTROL_RESET_REQ
-		      & readl(host->addr + HOST_CONTROL)))
-			goto reset_next;
+	int i;
+	j38ms_set_reg_mask(host,
+			HOST_CONTROL, reset_bit | HOST_CONTROL_CLOCK_EN);
 
+	for (i = 0; i < 20; ++i) {
+		if (!(j38ms_read_reg(host, HOST_CONTROL) & reset_bit))
+			break;
 		ndelay(20);
 	}
-	dev_dbg(&host->chip->pdev->dev, "reset_req timeout\n");
-	/* return -EIO; */
+	return (j38ms_read_reg(host, HOST_CONTROL) & reset_bit) ? EIO : 0;
+}
+
+/* Enable/disable the device */
+static int j38ms_power_device(struct j38ms_host *host, bool enable)
+{
+	int error;
 
-reset_next:
-	writel(HOST_CONTROL_RESET | HOST_CONTROL_CLOCK_EN
-	       | readl(host->addr + HOST_CONTROL),
-	       host->addr + HOST_CONTROL);
-	mmiowb();
+	if (enable) {
 
-	for (cnt = 0; cnt < 20; ++cnt) {
-		if (!(HOST_CONTROL_RESET
-		      & readl(host->addr + HOST_CONTROL)))
-			goto reset_ok;
+		error = j38ms_reset(host, HOST_CONTROL_RESET_REQ);
+		error = j38ms_reset(host, HOST_CONTROL_RESET);
+
+		if (error)
+			return error;
+
+		j38ms_write_reg(host, INT_SIGNAL_ENABLE, INT_STATUS_ALL);
+		j38ms_write_reg(host, INT_STATUS_ENABLE, INT_STATUS_ALL);
+		j38ms_write_reg(host, CLOCK_CONTROL, CLOCK_CONTROL_RESET);
+
+		j38ms_write_reg(host, HOST_CONTROL,
+			HOST_CONTROL_POWER_EN |
+			HOST_CONTROL_CLOCK_EN |
+			HOST_CONTROL_HW_OC_P |
+			HOST_CONTROL_TDELAY_EN |
+			HOST_CONTROL_BSY_TIME);
+
+		j38ms_write_reg(host, PAD_PU_PD, host->id ?
+			PAD_PU_PD_ON_MS_SOCK1 : PAD_PU_PD_ON_MS_SOCK0);
+
+		j38ms_write_reg(host, PAD_OUTPUT_ENABLE, PAD_OUTPUT_ENABLE_MS);
+
+	} else {
+		j38ms_clear_reg_mask(host, HOST_CONTROL,
+			HOST_CONTROL_POWER_EN | HOST_CONTROL_CLOCK_EN);
+		j38ms_write_reg(host, PAD_OUTPUT_ENABLE, 0);
+		j38ms_write_reg(host, PAD_PU_PD, PAD_PU_PD_OFF);
+		j38ms_write_reg(host, CLOCK_CONTROL, CLOCK_CONTROL_OFF);
 
-		ndelay(20);
 	}
-	dev_dbg(&host->chip->pdev->dev, "reset timeout\n");
-	return -EIO;
+	msleep(100);
+	return 0;
+}
 
-reset_ok:
-	mmiowb();
-	writel(INT_STATUS_ALL, host->addr + INT_SIGNAL_ENABLE);
-	writel(INT_STATUS_ALL, host->addr + INT_STATUS_ENABLE);
+/* Switch interface */
+static int j38ms_set_interface(struct j38ms_host *host, int interface)
+{
+	u32 host_ctl = j38ms_read_reg(host, HOST_CONTROL);
+	u32 clock_ctl = CLOCK_CONTROL_40MHZ;
+	u32 clock_delay;
+
+	host_ctl &= ~HOST_CONTROL_IF_MASK;
+	pci_read_config_dword(host->chip->pdev, PCI_CTL_CLOCK_DLY_ADDR,
+				&clock_delay);
+
+	clock_delay &= host->id ? ~PCI_CTL_CLOCK_DLY_MASK_B
+				: ~PCI_CTL_CLOCK_DLY_MASK_A;
+
+	if (interface == MEMSTICK_SERIAL) {
+
+		host_ctl |= HOST_CONTROL_IF_SERIAL;
+		clock_ctl = CLOCK_CONTROL_40MHZ;
+
+		host_ctl &= ~HOST_CONTROL_FAST_CLK;
+		host_ctl &= ~HOST_CONTROL_REO;
+		host_ctl |= HOST_CONTROL_REI;
+
+	} else if (interface == MEMSTICK_PAR4) {
+
+		host_ctl |= HOST_CONTROL_IF_PAR4;
+		clock_ctl = CLOCK_CONTROL_40MHZ;
+
+		host_ctl |= HOST_CONTROL_FAST_CLK;
+		host_ctl |= HOST_CONTROL_REO;
+		host_ctl &= ~HOST_CONTROL_REI;
+
+		clock_delay |= host->id ? (4 << 12) : (4 << 8);
+
+	} else if (interface == MEMSTICK_PAR8) {
+
+		host_ctl |= HOST_CONTROL_IF_PAR8;
+		clock_ctl = CLOCK_CONTROL_50MHZ;
+
+		host_ctl |= HOST_CONTROL_FAST_CLK;
+		host_ctl &= ~HOST_CONTROL_REO;
+		host_ctl &= ~HOST_CONTROL_REI;
+	} else
+		return -EINVAL;
+
+	j38ms_write_reg(host, HOST_CONTROL, host_ctl);
+	j38ms_write_reg(host, CLOCK_CONTROL, clock_ctl);
+
+	pci_write_config_dword(host->chip->pdev,
+		PCI_CTL_CLOCK_DLY_ADDR, clock_delay);
+
+	host->interface = interface;
 	return 0;
 }
 
+/* external interface: control hardware settings */
 static int j38ms_set_param(struct memstick_host *msh,
 			       enum memstick_param param,
 			       int value)
 {
 	struct j38ms_host *host = memstick_priv(msh);
-	unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
-	unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0;
-	int rc = 0;
 
 	switch (param) {
 	case MEMSTICK_POWER:
-		if (value == MEMSTICK_POWER_ON) {
-			rc = j38ms_reset(host);
-			if (rc)
-				return rc;
-
-			host_ctl = 7;
-			host_ctl |= HOST_CONTROL_POWER_EN
-				    | HOST_CONTROL_CLOCK_EN
-				    | HOST_CONTROL_HW_OC_P
-				    | HOST_CONTROL_TDELAY_EN;
-			writel(host_ctl, host->addr + HOST_CONTROL);
-
-			writel(host->id ? PAD_PU_PD_ON_MS_SOCK1
-					: PAD_PU_PD_ON_MS_SOCK0,
-			       host->addr + PAD_PU_PD);
-
-			writel(PAD_OUTPUT_ENABLE_MS,
-			       host->addr + PAD_OUTPUT_ENABLE);
-
-			msleep(10);
-			dev_dbg(&host->chip->pdev->dev, "power on\n");
-		} else if (value == MEMSTICK_POWER_OFF) {
-			host_ctl &= ~(HOST_CONTROL_POWER_EN
-				      | HOST_CONTROL_CLOCK_EN);
-			writel(host_ctl, host->addr +  HOST_CONTROL);
-			writel(0, host->addr + PAD_OUTPUT_ENABLE);
-			writel(PAD_PU_PD_OFF, host->addr + PAD_PU_PD);
-			dev_dbg(&host->chip->pdev->dev, "power off\n");
-		} else
-			return -EINVAL;
-		break;
+		return j38ms_power_device(host, (value == MEMSTICK_POWER_ON));
 	case MEMSTICK_INTERFACE:
-		host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT);
-		pci_read_config_dword(host->chip->pdev,
-				      PCI_CTL_CLOCK_DLY_ADDR,
-				      &clock_delay);
-		clock_delay &= host->id ? ~PCI_CTL_CLOCK_DLY_MASK_B
-					: ~PCI_CTL_CLOCK_DLY_MASK_A;
-
-		if (value == MEMSTICK_SERIAL) {
-			host_ctl &= ~HOST_CONTROL_FAST_CLK;
-			host_ctl &= ~HOST_CONTROL_REO;
-			host_ctl |= HOST_CONTROL_IF_SERIAL
-				    << HOST_CONTROL_IF_SHIFT;
-			host_ctl |= HOST_CONTROL_REI;
-			clock_ctl = CLOCK_CONTROL_40MHZ;
-		} else if (value == MEMSTICK_PAR4) {
-			host_ctl |= HOST_CONTROL_FAST_CLK | HOST_CONTROL_REO;
-			host_ctl |= HOST_CONTROL_IF_PAR4
-				    << HOST_CONTROL_IF_SHIFT;
-			host_ctl &= ~HOST_CONTROL_REI;
-			clock_ctl = CLOCK_CONTROL_40MHZ;
-			clock_delay |= host->id ? (4 << 12) : (4 << 8);
-		} else if (value == MEMSTICK_PAR8) {
-			host_ctl |= HOST_CONTROL_FAST_CLK;
-			host_ctl |= HOST_CONTROL_IF_PAR8
-				    << HOST_CONTROL_IF_SHIFT;
-			host_ctl &= ~(HOST_CONTROL_REI | HOST_CONTROL_REO);
-			clock_ctl = CLOCK_CONTROL_50MHZ;
-		} else
-			return -EINVAL;
-
-		writel(host_ctl, host->addr + HOST_CONTROL);
-		writel(clock_ctl, host->addr + CLOCK_CONTROL);
-		pci_write_config_dword(host->chip->pdev,
-				       PCI_CTL_CLOCK_DLY_ADDR,
-				       clock_delay);
-		break;
+		return j38ms_set_interface(host, value);
+	default:
+		return -EINVAL;
 	};
-	return 0;
 }
 
 #ifdef CONFIG_PM
drivers/memstick/host/jmb38x_ms.h +5 -6
index 5d7ad18..4ece074 100644
@@ -48,15 +48,13 @@
 #define HOST_CONTROL_FAST_CLK   0x00000200
 #define HOST_CONTROL_RESET      0x00000100
 #define HOST_CONTROL_POWER_EN   0x00000080
+#define HOST_CONTROL_IF_PAR4    0x00000010
+#define HOST_CONTROL_IF_PAR8    0x00000030
+#define HOST_CONTROL_IF_MASK    0x00000030
 #define HOST_CONTROL_CLOCK_EN   0x00000040
 #define HOST_CONTROL_REO        0x00000008
 #define HOST_CONTROL_BSY_TIME	0x00000007
-
-#define HOST_CONTROL_IF_SHIFT  4
-#define HOST_CONTROL_IF_SERIAL 0x0
-#define HOST_CONTROL_IF_PAR4   0x1
-#define HOST_CONTROL_IF_PAR8   0x3
-
+#define HOST_CONTROL_IF_SERIAL  0x00000000
 
 /* IO window for PIO access to internal FIFO*/
 #define	DATA                   0x1c
@@ -156,6 +154,7 @@ struct j38ms_host {
 	struct timer_list       timer;
 	struct memstick_request *req;
 	unsigned char           cmd_flags;
+	int                     interface;
 
 	/* PIO state */
 	struct sg_mapping_iter  pio_sg_iter;
Signature · 1 line
1.7.1
maintainer
#74 lore raw

Re: [PATCH 26/29] memstick: jmb38x_ms: rework hardware setup/reset

Quoted 10 lines · Maxim Levitsky

From: Maxim Levitsky <[email protected]>
Subject: [PATCH 26/29] memstick: jmb38x_ms: rework hardware setup/reset
To: "Alex Dubov" <[email protected]>
Cc: "Andrew Morton" <[email protected]>, "LKML" <[email protected]>, "Maxim Levitsky" <[email protected]>
Received: Friday, 22 October, 2010, 4:53 PM
Move the code into functions.
Reset clock on init - fixes serial mode

---

Ok.

author maintainer
#75 lore raw

PATCH 27/29 memstick: jmb38x_ms: minor additions.

In reply to Maxim Levitsky

* Add my copyright
* Add module param descriprion

---
 drivers/memstick/host/jmb38x_ms.c |    9 ++++++---
 1 files changed, 6 insertions(+), 3 deletions(-)
drivers/memstick/host/jmb38x_ms.c +6 -3
index 86c003a..0a1bb25 100644
@@ -2,6 +2,7 @@
  *  jmb38x_ms.c - JMicron jmb38x MemoryStick card reader
  *
  *  Copyright (C) 2008 Alex Dubov <[email protected]>
+ *  Copyright (C) 2010 Maxim Levitsky <[email protected]>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -955,13 +956,15 @@ static void __exit j38ms_exit(void)
 }
 
 MODULE_AUTHOR("Alex Dubov");
-MODULE_DESCRIPTION("JMicron jmb38x MemoryStick driver");
+MODULE_DESCRIPTION("JMicron jm38x_ms MemoryStick driver");
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, j38ms_id_tbl);
 
-module_param(no_dma, bool, S_IRUGO);
-module_param(debug, bool, S_IRUGO);
+module_param(debug, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug level (0-3)");
 
+module_param(no_dma, bool, 0644);
+MODULE_PARM_DESC(no_dma, "Disable the dma");
 
 module_init(j38ms_init);
 module_exit(j38ms_exit);
Signature · 1 line
1.7.1
author maintainer
#76 lore raw

PATCH 28/29 memstick: add support for legacy memorysticks

In reply to Maxim Levitsky

Huge thanks for Alex Dubov for code that this is based on and for lot, really lot of help he gave me in understanding MemorySticks and implementing this driver. His help made this driver possible.

As any code that works with user data this driver isn't recommened to use with valuable data.

It tries its best though to avoid data corruption and possible damage to the card.

Tested with MS DUO 64 MB card on Ricoh and Jmicron reader.

---
 MAINTAINERS                      |    5 +
 drivers/memstick/core/Kconfig    |   12 +
 drivers/memstick/core/Makefile   |    2 +-
 drivers/memstick/core/ms_block.c | 2226 ++++++++++++++++++++++++++++++++++++++
 drivers/memstick/core/ms_block.h |  229 ++++
 5 files changed, 2473 insertions(+), 1 deletions(-)
 create mode 100644 drivers/memstick/core/ms_block.c
 create mode 100644 drivers/memstick/core/ms_block.h
MAINTAINERS +5 -0
index 7679bf3..71df8db 100644
@@ -5443,6 +5443,11 @@ W:	http://tifmxx.berlios.de/
 S:	Maintained
 F:	drivers/memstick/host/tifm_ms.c
 
+SONY MEMORYSTICK STANDARD SUPPORT
+M:	Maxim Levitsky <[email protected]>
+S:	Maintained
+F:	drivers/memstick/core/ms_block.*
+
 SOUND
 M:	Jaroslav Kysela <[email protected]>
 M:	Takashi Iwai <[email protected]>
drivers/memstick/core/Kconfig +12 -0
index 95f1814..f79f2a8 100644
@@ -24,3 +24,15 @@ config MSPRO_BLOCK
 	  support. This provides a block device driver, which you can use
 	  to mount the filesystem. Almost everyone wishing MemoryStick
 	  support should say Y or M here.
+
+config MS_BLOCK
+	tristate "MemoryStick Standard device driver"
+	depends on BLOCK && EXPERIMENTAL
+	help
+	  Say Y here to enable the MemoryStick Standard device driver
+	  support. This provides a block device driver, which you can use
+	  to mount the filesystem.
+	  This driver works with old (bulky) MemoryStick and MemoryStick Duo
+	  but not PRO. Say Y if you have such card.
+	  Driver is new and not yet well tested, thus it can damage your card
+	  (even permanently)
drivers/memstick/core/Makefile +1 -1
index 8b2b529..19d960b 100644
@@ -7,5 +7,5 @@ ifeq ($(CONFIG_MEMSTICK_DEBUG),y)
 endif
 
 obj-$(CONFIG_MEMSTICK)		+= memstick.o
-
+obj-$(CONFIG_MS_BLOCK)		+= ms_block.o
 obj-$(CONFIG_MSPRO_BLOCK)	+= mspro_block.o
drivers/memstick/core/ms_block.c new file +2226 -0

2,226 lines not on this page · raw message

drivers/memstick/core/ms_block.h new file +229 -0

229 lines not on this page · raw message

Signature · 1 line
1.7.1
author maintainer
#77 lore raw

PATCH 29/29 memstick: Add driver for Ricoh R5C592 Card reader.

In reply to Maxim Levitsky
---
 MAINTAINERS                    |    5 +
 drivers/memstick/host/Kconfig  |   12 +
 drivers/memstick/host/Makefile |    1 +
 drivers/memstick/host/r592.c   |  878 ++++++++++++++++++++++++++++++++++++++++
 drivers/memstick/host/r592.h   |  175 ++++++++
 5 files changed, 1071 insertions(+), 0 deletions(-)
 create mode 100644 drivers/memstick/host/r592.c
 create mode 100644 drivers/memstick/host/r592.h
MAINTAINERS +5 -0
index 71df8db..4ff3fce 100644
@@ -4919,6 +4919,11 @@ S:	Maintained
 F:	drivers/mtd/nand/r852.c
 F:	drivers/mtd/nand/r852.h
 
+RICOH R5C592 MEMORYSTICK DRIVER
+M:	Maxim Levitsky <[email protected]>
+S:	Maintained
+F:	drivers/memstick/host/r592.*
+
 RISCOM8 DRIVER
 S:	Orphan
 F:	Documentation/serial/riscom8.txt
drivers/memstick/host/Kconfig +12 -0
index 4ce5c8d..cc0997a 100644
@@ -30,3 +30,15 @@ config MEMSTICK_JMICRON_38X
 
           To compile this driver as a module, choose M here: the
 	  module will be called jmb38x_ms.
+
+config MEMSTICK_R592
+	tristate "Ricoh R5C592 MemoryStick interface support (EXPERIMENTAL)"
+	depends on EXPERIMENTAL && PCI
+
+	help
+	  Say Y here if you want to be able to access MemoryStick cards with
+	  the Ricoh R5C592 MemoryStick card reader (which is part of 5 in one
+		multifunction reader)
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called r592.
drivers/memstick/host/Makefile +1 -0
index 12530e4..ad63c16 100644
@@ -8,3 +8,4 @@ endif
 
 obj-$(CONFIG_MEMSTICK_TIFM_MS)		+= tifm_ms.o
 obj-$(CONFIG_MEMSTICK_JMICRON_38X)	+= jmb38x_ms.o
+obj-$(CONFIG_MEMSTICK_R592)		+= r592.o
drivers/memstick/host/r592.c new file +878 -0

878 lines not on this page · raw message

drivers/memstick/host/r592.h new file +175 -0

175 lines not on this page · raw message

Signature · 1 line
1.7.1
author maintainer
#78 lore raw
In reply to Maxim Levitsky
Quoted 5 lines · Maxim Levitsky

Hi,

As requested, this is split up series of the work I did for the memorystick subsystem.

Quoted 7 lines

All patches compile tested.
All patches except jmicron patches also run tested on my r592
The end result of jmicron patches is exactly the same as my old patch that did work very well. I will test the patches tommorow though to ensure that all of them work for bisectability.

Please review & merge.

Any update?
Can I expect this in 2.6.37?

Best regards,
Maxim Levitsky

maintainer
#79 lore raw
Quoted 5 lines · Maxim Levitsky
Quoted 1 line

Any update?
Can I expect this in 2.6.37?

If I understand the process correctly, probably no. It's going to take more time, considering the volume and nature of changes.

There's also additional very unfortunate property of your patchset, namely you're mixing purely cosmetic and functional patches. Normally, functional patches should precede the cosmetic one, so that the functionality can be discussed first.

#80 lore raw
Quoted 3 lines · On Mon, 25 Oct 2010 07:39:58 -0700 (PDT) Alex Dubov <[email protected]> wrote:

Normally, functional
patches should precede the cosmetic one, so that the functionality can be discussed first.

More usually it's the other way around, actually: cleanups come first.

Because the cleanups are usually uncontroversial, and because substantive changes against cleaner code are easier to review/understand and because the substantive changes are then easier to revert or fix.

maintainer
#81 lore raw
Quoted 9 lines
Quoted 3 lines

Normally, functional
patches should precede the cosmetic one, so that the

functionality can be

Quoted 1 line

discussed first.

More usually it's the other way around, actually: cleanups come first.

Quoted 7 lines

Because the cleanups are usually uncontroversial, and because
substantive changes against cleaner code are easier to review/understand and because the substantive changes are then easier
to revert or fix.

My problem here is that out of 30 patches, 20 appear to be rewrites and clean-ups of things not broken.

That's why I'd rather prefer to see actual functional changes first.

author maintainer
#82 lore raw
In reply to Andrew Morton
Quoted 6 lines · Andrew Morton
Quoted 3 lines · On Mon, 25 Oct 2010 07:39:58 -0700 (PDT) Alex Dubov <[email protected]> wrote:

Normally, functional
patches should precede the cosmetic one, so that the functionality can be discussed first.

Quoted 6 lines

More usually it's the other way around, actually: cleanups come first.

Because the cleanups are usually uncontroversial, and because substantive changes against cleaner code are easier to review/understand and because the substantive changes are then easier to revert or fix.

Exactly.

Now let me explain another technical reason why I did it that way. First I created one big patch per driver I changed.
It really wasn't reviewable, but it was intended to review the end result (the source file after patch was applied).
I did that because its really slows you down when you try to edit at same time many patches. You have endless conflicts, you do lot of work that you just remove in next patch etc.
Anyway this patchseries is a result of a lot of hard work (about month).

Alex pointer me that that isn't acceptable in linux community. OK. I decided to bite the bullet and do that. It took me 2 full days to split patches, test them (after all, I do honor the rule of bisesctability).

Now why I put the cosmetic patches first?

Because that reduces conflicts during patch splitting dramaticly.

Consider this stack:

3: <top>
2: <few functions moved>
1: <few functions rewritten>
0: <existing source>

If I want to change patch #1, I will have to redo the patch #2 from the start. That really sucks.

Now I could skip the functions that move code around, rename functions etc to make Alex happy, but my goal was to minimize differences between split-up series and original patch, so I could spare hard debugging.

This is result of lot of hard work.
I really want to see that in 2.6.37.

Best regards,
Maxim Levitsky

maintainer
#83 lore raw
In reply to Maxim Levitsky

I would like to summarize my impression until now:

1. There are 3 functional fixes to Jmicron driver, which are rather small when taken to their essence (disregarding renames and idle code movements).

2. There is 1 functional enhancement to the MS Pro driver, not too big, pertaining to extended command execution and resulting in 10% speedup in some cases.

3. There are 25 patches which just rewrite everything for no good reason (by this I mean bugs or missing functionality).

Why don't we deal with p.1 and p.2 first, before going to the p.3, as I suggested from the beginning?

I don't have any specific objections to Ricoh driver as it is.