/* -*- mode: c; c-basic-offset: 8; -*- * vim: noexpandtab sw=8 ts=8 sts=0: * * stackglue.h * * Glue to the underlying cluster stack. * * Copyright (C) 2007 Oracle. All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. */ #ifndef STACKGLUE_H #define STACKGLUE_H #include #include #include #include "dlm/dlmapi.h" #include /* Needed for plock-related prototypes */ struct file; struct file_lock; /* * dlmconstants.h does not have a LOCAL flag. We hope to remove it * some day, but right now we need it. Let's fake it. This value is larger * than any flag in dlmconstants.h. */ #define DLM_LKF_LOCAL 0x00100000 /* * This shadows DLM_LOCKSPACE_LEN in fs/dlm/dlm_internal.h. That probably * wants to be in a public header. */ #define GROUP_NAME_MAX 64 /* This shadows OCFS2_CLUSTER_NAME_LEN */ #define CLUSTER_NAME_MAX 16 /* * ocfs2_protocol_version changes when ocfs2 does something different in * its inter-node behavior. See dlmglue.c for more information. */ struct ocfs2_protocol_version { u8 pv_major; u8 pv_minor; }; /* * The dlm_lockstatus struct includes lvb space, but the dlm_lksb struct only * has a pointer to separately allocated lvb space. This struct exists only to * include in the lksb union to make space for a combined dlm_lksb and lvb. */ struct fsdlm_lksb_plus_lvb { struct dlm_lksb lksb; char lvb[DLM_LVB_LEN]; }; /* * A union of all lock status structures. We define it here so that the * size of the union is known. Lock status structures are embedded in * ocfs2 inodes. */ struct ocfs2_cluster_connection; struct ocfs2_dlm_lksb { union { struct dlm_lockstatus lksb_o2dlm; struct dlm_lksb lksb_fsdlm; struct fsdlm_lksb_plus_lvb padding; }; struct ocfs2_cluster_connection *lksb_conn; }; /* * The ocfs2_locking_protocol defines the handlers called on ocfs2's behalf. */ struct ocfs2_locking_protocol { struct ocfs2_protocol_version lp_max_version; void (*lp_lock_ast)(struct ocfs2_dlm_lksb *lksb); void (*lp_blocking_ast)(struct ocfs2_dlm_lksb *lksb, int level); void (*lp_unlock_ast)(struct ocfs2_dlm_lksb *lksb, int error); }; /* * A cluster connection. Mostly opaque to ocfs2, the connection holds * state for the underlying stack. ocfs2 does use cc_version to determine * locking compatibility. */ struct ocfs2_cluster_connection { char cc_name[GROUP_NAME_MAX + 1]; int cc_namelen; char cc_cluster_name[CLUSTER_NAME_MAX + 1]; int cc_cluster_name_len; struct ocfs2_protocol_version cc_version; struct ocfs2_locking_protocol *cc_proto; void (*cc_recovery_handler)(int node_num, void *recovery_data); void *cc_recovery_data; void *cc_lockspace; void *cc_private; }; /* * Each cluster stack implements the stack operations structure. Not used * in the ocfs2 code, the stackglue code translates generic cluster calls * into stack operations. */ struct ocfs2_stack_operations { /* * The fs code calls ocfs2_cluster_connect() to attach a new * filesystem to the cluster stack. The ->connect() op is passed * an ocfs2_cluster_connection with the name and recovery field * filled in. * * The stack must set up any notification mechanisms and create * the filesystem lockspace in the DLM. The lockspace should be * stored on cc_lockspace. Any other information can be stored on * cc_private. * * ->connect() must not return until it is guaranteed that * * - Node down notifications for the filesystem will be received * and passed to conn->cc_recovery_handler(). * - Locking requests for the filesystem will be processed. */ int (*connect)(struct ocfs2_cluster_connection *conn); /* * The fs code calls ocfs2_cluster_disconnect() when a filesystem * no longer needs cluster services. All DLM locks have been * dropped, and recovery notification is being ignored by the * fs code. The stack must disengage from the DLM and discontinue * recovery notification. * * Once ->disconnect() has returned, the connection structure will * be freed. Thus, a stack must not return from ->disconnect() * until it will no longer reference the conn pointer. * * Once this call returns, the stack glue will be dropping this * connection's reference on the module. */ int (*disconnect)(struct ocfs2_cluster_connection *conn); /* * ->this_node() returns the cluster's unique identifier for the * local node. */ int (*this_node)(struct ocfs2_cluster_connection *conn, unsigned int *node); /* * Call the underlying dlm lock function. The ->dlm_lock() * callback should convert the flags and mode as appropriate. * * ast and bast functions are not part of the call because the * stack will likely want to wrap ast and bast calls before passing * them to stack->sp_proto. There is no astarg. The lksb will * be passed back to the ast and bast functions. The caller can * use this to find their object. */ int (*dlm_lock)(struct ocfs2_cluster_connection *conn, int mode, struct ocfs2_dlm_lksb *lksb, u32 flags, void *name, unsigned int namelen); /* * Call the underlying dlm unlock function. The ->dlm_unlock() * function should convert the flags as appropriate. * * The unlock ast is not passed, as the stack will want to wrap * it before calling stack->sp_proto->lp_unlock_ast(). There is * no astarg. The lksb will be passed back to the unlock ast * function. The caller can use this to find their object. */ int (*dlm_unlock)(struct ocfs2_cluster_connection *conn, struct ocfs2_dlm_lksb *lksb, u32 flags); /* * Return the status of the current lock status block. The fs * code should never dereference the union. The ->lock_status() * callback pulls out the stack-specific lksb, converts the status * to a proper errno, and returns it. */ int (*lock_status)(struct ocfs2_dlm_lksb *lksb); /* * Return non-zero if the LVB is valid. */ int (*lvb_valid)(struct ocfs2_dlm_lksb *lksb); /* * Pull the lvb pointer off of the stack-specific lksb. */ void *(*lock_lvb)(struct ocfs2_dlm_lksb *lksb); /* * Cluster-aware posix locks * * This is NULL for stacks which do not support posix locks. */ int (*plock)(struct ocfs2_cluster_connection *conn, u64 ino, struct file *file, int cmd, struct file_lock *fl); /* * This is an optoinal debugging hook. If provided, the * stack can dump debugging information about this lock. */ void (*dump_lksb)(struct ocfs2_dlm_lksb *lksb); }; /* * Each stack plugin must describe itself by registering a * ocfs2_stack_plugin structure. This is only seen by stackglue and the * stack driver. */ struct ocfs2_stack_plugin { char *sp_name; struct ocfs2_stack_operations *sp_ops; struct module *sp_owner; /* These are managed by the stackglue code. */ struct list_head sp_list; unsigned int sp_count; struct ocfs2_protocol_version sp_max_proto; }; /* Used by the filesystem */ int ocfs2_cluster_connect(const char *stack_name, const char *cluster_name, int cluster_name_len, const char *group, int grouplen, struct ocfs2_locking_protocol *lproto, void (*recovery_handler)(int node_num, void *recovery_data), void *recovery_data, struct ocfs2_cluster_connection **conn); /* * Used by callers that don't store their stack name. They must ensure * all nodes have the same stack. */ int ocfs2_cluster_connect_agnostic(const char *group, int grouplen, struct ocfs2_locking_protocol *lproto, void (*recovery_handler)(int node_num, void *recovery_data), void *recovery_data, struct ocfs2_cluster_connection **conn); int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn, int hangup_pending); void ocfs2_cluster_hangup(const char *group, int grouplen); int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn, unsigned int *node); struct ocfs2_lock_res; int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn, int mode, struct ocfs2_dlm_lksb *lksb, u32 flags, void *name, unsigned int namelen); int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn, struct ocfs2_dlm_lksb *lksb, u32 flags); int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb); int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb); void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb); void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb); int ocfs2_stack_supports_plocks(void); int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino, struct file *file, int cmd, struct file_lock *fl); void ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version *max_proto); /* Used by stack plugins */ int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin); void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin); /* In ocfs2_downconvert_lock(), we need to know which stack we are using */ int ocfs2_is_o2cb_active(void); extern struct kset *ocfs2_kset; #endif /* STACKGLUE_H */ [<c010ff84>] (blkdev_fsync+0x34/0x44) [ 240.738083] [<c010ff84>] (blkdev_fsync) from [<c0109594>] (do_fsync+0x3c/0x64) [ 240.745319] [<c0109594>] (do_fsync) from [<c000ffc0>] (ret_fast_syscall+0x0/0x3c) .. Here is the detailed sequence showing when this issue may happen: 1) At probe time, mmci device is initialized and card busy detection based on DAT[0] monitoring is enabled. 2) Later during run time, since card reported to support internal caches, a MMCI_SWITCH command is sent to eMMC device with FLUSH_CACHE operation. On receiving this command, eMMC may enter busy state (for a relatively short time in the case of the dead-lock). 3) Then mmci interrupt is raised and mmci_irq() is called: MMCISTATUS register is read and is equal to 0x01000440. So the following status bits are set: - MCI_CMDRESPEND (= 6) - MCI_DATABLOCKEND (= 10) - MCI_ST_CARDBUSY (= 24) Since MMCIMASK0 register is 0x3FF, status variable is set to 0x00000040 and BIT MCI_CMDRESPEND is cleared by writing MMCICLEAR register. Then mmci_cmd_irq() is called. Considering the following conditions: - host->busy_status is 0, - this is a "busy response", - reading again MMCISTATUS register gives 0x1000400, MMCIMASK0 is updated to unmask MCI_ST_BUSYEND bit. Thus, MMCIMASK0 is set to 0x010003FF and host->busy_status is set to wait for busy end completion. Back again in status loop of mmci_irq(), we quickly go through mmci_data_irq() as there are no data in that case. And we finally go through following test at the end of while(status) loop: /* * Don't poll for busy completion in irq context. */ if (host->variant->busy_detect && host->busy_status) status &= ~host->variant->busy_detect_flag; Because status variable is not yet null (is equal to 0x40), we do not leave interrupt context yet but we loop again into while(status) loop. So we run across following steps: a) MMCISTATUS register is read again and this time is equal to 0x01000400. So that following bits are set: - MCI_DATABLOCKEND (= 10) - MCI_ST_CARDBUSY (= 24) Since MMCIMASK0 register is equal to 0x010003FF: b) status variable is set to 0x01000000. c) MCI_ST_CARDBUSY bit is cleared by writing MMCICLEAR register. Then, mmci_cmd_irq() is called one more time. Since host->busy_status is set and that MCI_ST_CARDBUSY is set in status variable, we just return from this function. Back again in mmci_irq(), status variable is set to 0 and we finally leave the while(status) loop. As a result we leave interrupt context, waiting for busy end interrupt event. Now, consider that busy end completion is raised IN BETWEEN steps 3.a) and 3.c). In such a case, we may mistakenly clear busy end interrupt at step 3.c) while it has not yet been processed. This will result in mmc command to wait forever for a busy end completion that will never happen. To fix the problem, this patch implements the following changes: Considering that the mmci seems to be triggering the IRQ on both edges while monitoring DAT0 for busy completion and that same status bit is used to monitor start and end of busy detection, special care must be taken to make sure that both start and end interrupts are always cleared one after the other. 1) Clearing of card busy bit is moved in mmc_cmd_irq() function where unmasking of busy end bit is effectively handled. 2) Just before unmasking busy end event, busy start event is cleared by writing card busy bit in MMCICLEAR register. 3) Finally, once we are no more busy with a command, busy end event is cleared writing again card busy bit in MMCICLEAR register. This patch has been tested with the ST Accordo5 machine, not yet supported upstream but relies on the mmci driver. Signed-off-by: Sarang Mairal <sarang.mairal@garmin.com> Signed-off-by: Jean-Nicolas Graux <jean-nicolas.graux@st.com> Reviewed-by: Linus Walleij <linus.walleij@linaro.org> Tested-by: Ulf Hansson <ulf.hansson@linaro.org> Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
Diffstat (limited to 'drivers/usb/isp1760/isp1760-udc.h')